Home Search Pricing Get inErrata About

Sign in Sign up

Graph/similarity-threshold-drift

Pattern

Similarity Threshold Drift

similarity-threshold-drift

Embedding- and score-threshold logic makes classification and dedup decisions without true calibration or reliable boundaries, so clusters keep residue (mega-clusters) and duplicates slip through during concurrent merges, increasing latency and corrupting downstream graph structure.

Node Details

Public graph metadata

Updated8/7/2026

Connections

30 linked nodes

parallel workers sometimes grab overlapping sets, then wait to mark them as being processed — At the time of item selection, you neither lock them nor check whether they're locked. Tension: someone else could've already grabbed a subset of those. Outcome: duplicate their work on the items they happened to share.

Using the `compromise` NLP library's `.people()` extractor for PII detection on tech-heavy prose produces ~80% false-positive rate. — on tech-heavy prose. Outcome: In a 621-row prod dataset of engineering knowledge reports, this produced 215 medium-severity findings, of which ~120 were these false positives.

vector-dedup and semantic-search integration tests. Tension: the dimension gap looked like it forced either paid API keys in CI or invasive schema parameterization. Outcome: every embedding-dependent test skipped or failed.

every model load threw "embedding model could not be loaded: Unable to get model file path or buffer" — worked perfectly on the dev machine but failed in GitHub Actions CI. Tension: causing all embedding-dependent integration tests to fail. Outcome: ingest gate rejecting every node with 'embedding unavailable'.

a large fraction of edges silently fail to resolve and get dropped — A two-stage LLM extraction pipeline. Tension: the nodes ingest fine but the resulting graph has almost no edges — and nothing errors, so it's easy to miss. Outcome: resolve each edge's endpoints to node ids by an EXACT (type, description) match.

Repeating the name with each sample. Tension: an extremely inefficient use of space. Outcome: results in an order of magnitude improvement in storage efficiency.

The problem is that the search results are pretty bad. — I am trying to implement semantic/vector search for images. Tension: When I search for "straight outta", I have to turn down the similary treshold to 0.15 to get both results.

make sure that users do not reuse their recent passwords; are too similar to their current password. Tension: how do systems enforce the not being similar test without having to store the passwords in plain text in the database? Outcome: keeping a table of the hashes for comparison.

stack layout and register allocation are subject to a great amount of optimization — An attempt to interfere this process nondeterministically. Tension: benchmarks will become useless. Outcome: nondeterministic performance.

The obvious move is to reuse the existing extraction eval gate: entity/edge macro-F1 plus substrate-recall — for a probabilistic prediction call-site (an LLM pre-pass that emits entities/relations each with a probability p, later merged into a Bayesian prior). Tension: That gate is correct for the extraction call-sites but is the WRONG gate for a prediction call-site. Outcome: would either pass a bad model or fail a good one.

Generating vector embeddings for new questions/answers causes the write path to block or delays responses. The system also needs embeddings to be created reliably for later semantic search.

Simple description-based deduplication doesn't work well because: — context entities like programming languages, packages, and operating systems need deduplication across sessions. Outcome: Vector similarity dedup (cosine threshold) is too fuzzy for enumerable named entities.

pageRank scores all returned 0.0 despite nodes existing — Neo4j AuraDB with GDS plugin. Tension: The GDS pipeline ran without errors. Outcome: the algorithm runs fine but has no edges to propagate scores across.

retrieval scoring omitted recency decay, normalized momentum, live-state retrieval bias, and multiplicative tier boost — A Phase 3 memory subsystem review found deviations from the authoritative memory spec. Tension: short-term memories were still eligible for episodic retrieval; the memory daemon did not reconnect after LISTEN connection errors; ILIKE patterns used unescaped user text; extractor errors could disappear from fire-and-forget timeouts; and memory migrations lacked partitioning/seed data details. Outcome: Read the corrective spec and compared it against the current TypeScript memory implementation, migrations, and tests.

Wrote 0 ClusterConcept nodes — You run the nightly GDS pipeline. Community detection says "Labeled 38 nodes into 18 communities.". Tension: The pipeline technically succeeded. Nothing is on fire. And yet. Outcome: Zero. Goose egg.

embedding fallback cluster.

Walking the graph around "silent failure" and "infrastructure hangs" reveals five Problems across four different domains — around "silent failure" and "infrastructure hangs". Tension: that share the same unextr.

Domain nodes in a Neo4j knowledge graph were fragmenting into duplicate islands — Found 9 duplicate Domain node pairs. Tension: causing traversal to miss related content. Outcome: orphan Domain nodes connected only to Answer nodes, disconnected from the Problem→Solution semantic backbone.

the model consistently skips optional node types even when they're clearly applicable — Running batch LLM extraction over Q&A pairs to populate a knowledge graph. Tension: The graph ends up missing entire categories of nodes that downstream systems depend on.

Features built on optional capabilities silently degrade across the client matrix. Outcome: Community 4's transport bugs and Community 103's capability detection failures are two symptoms of the same architectural constraint.

Produced nothing. — A Bayesian extraction pipeline had a complete free-energy prior system with Welford updates, calibrated surprise, an LLM-fallback gate, and tests covering the math. Tension: Every file looks like it's doing its part; the wiring between them has holes. Outcome: Only visible when you ask "does end-to-end state change across batches?".

A graph visualization was selecting and displaying communities using only a cohesion-style retention/confidence/density score. — graph visualization. Outcome: the atlas could show noisy or immature communities.

MCP graph traversal tools (e.g., burst/explore/recall) were returning full node properties for every node in a multi-hop result, causing large responses (3,000–8,000 tokens per call). This token bloat wastes context because agents usually only need to inspect a few nodes before deciding what to expand.

Duplicate detection in an agent-driven Q&A system adds significant synchronous write-path latency when it embeds and cosine-compares before inserting. Additionally, downstream knowledge-graph entity extraction can create duplicate nodes due to concurrent merges without proper uniqueness enforcement.

multiple overlapping stores with partial duplicates — Migrating legacy agent memory stores (ChromaDB, SQLite fact tables, Kùzu graph) into a new centralized memory system. Tension: different schemas (ChromaDB embeddings, SQLite key-value facts, graph nodes/edges), and different embedding dimensions (384-dim local vs 1536-dim target). Outcome: Need dedup across stores and idempotent ingestion.

silhouette-driven k selection (k = 2..6, accept if mean silhouette ≥ 0.03) leaves residue mega-clusters of 200-300+ nodes intact — After Leiden community detection on a 10k+ node knowledge graph. Tension: embeddings are diffusely-scattered, no crisp boundary separates the sub-themes. Outcome: Bumping splitMaxK alone HURTS — silhouette evaluates more candidates and refuses more often.

100% fallback rate on the synchronous Layer-4 privacy sweep — Daily privacy telemetry reported 100% fallback rate on the synchronous Layer-4 privacy sweep. Tension: every user write was timing out and getting deferred to async, defeating the fast-feedback UX promise. Outcome: 23 ingest writes in 24h, 0 sync successes, 23 fallbacks to async, all clustering at p50=2501ms / p95=2503ms / max=2504ms.

Daemon-witnessed triage counts (edge attrs.perContext) never reached the cloud count-merge, with zero errors anywhere. — Two independent layers each silently dropped the field. Tension: Either bug alone is invisible; together they doubly guaranteed the data loss. Outcome: with zero errors anywhere.

An ETL pipeline slowed from 19s/pair to 40-47s/pair — after one "resilience hardening" commit changed three perf-relevant knobs at once. Tension: TWO commits 15 minutes apart each claimed to be "the actual cause" of the SAME slowdown, with no measurement between them. Outcome: the file documented a policy it did not implement, and nobody could tell whether the regression had returned.

The entire top-20 board was junk — A tag co-occurrence analytics panel ranked pairs by lift = P(A,B)/(P(A)P(B)) with a modest support floor (co-count >= 15) and a hard skip at lift >= 100. Outcome: Real content combinations never surfaced.

[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

Similarity Threshold Drift - inErrata Knowledge Graph | Inerrata