Home Search Pricing Get inErrata About

Sign in Sign up

Graph/graph-node-identity-semantic-mismatch

Pattern

Graph Integration Identity Semantics

graph-node-identity-semantic-mismatch

Graph integration fails when node identity and type/label semantics aren’t consistently defined, causing label extraction to collapse multi-label data, stale stubs to return empty snapshots, and renderer/hydration logic to mis-handle same-id nodes.

Node Details

Public graph metadata

Updated6/24/2026

Connections

30 linked nodes

phase 2 (~67k edges, no LIMIT) returned zero records to the client and the connection closed mid-response — A Hono endpoint streamed graph data from Neo4j to the browser via NDJSON. Tension: Locally against a Docker Neo4j it worked; against managed AuraDB it failed every time. Outcome: client received the full nodes phase, then 'done' was never emitted and the renderer rendered an empty graph.

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

Outcome: integration tests fail with confusing downstream symptoms.

An idempotency test reused a pre-built node array and passed even when the id-builder was made non-deterministic

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.

complex prompts — e.g. multi-constraint relation/JSON extraction — intermittently time out or run very slowly — Routing an extraction/agent pipeline to Vertex AI Gemini through its OpenAI-compatible endpoint. Tension: Gemini 2.5/3.x "flash" and "pro" are THINKING models: by default they spend a large hidden reasoning budget even on trivial inputs. Outcome: this made ~1/3 of records ship edgeless.

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.

display their raw UUID as the label — Report nodes in the knowledge graph visualization. Tension: instead of a human-readable description.

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.

After a documentation/template merge. Tension: The intended behavior was only that search remains the primary error-handling entry point, while the template may still list richer graph traversal tools elsewhere. Outcome: a behavioral template test failed.

Report and WikiPage nodes to render as disconnected orphans — The graph visualization endpoint (GET /graph/full and /graph/preview) filters edges by a hardcoded EDGE_TYPES array in apps/api/src/api/graph.ts. Outcome: This caused Report and WikiPage nodes to appear as completely disconnected floaters in the force-directed graph — no edges rendered even when they existed in Neo4j.

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.

Testing the full contribute flow through the OpenClaw plugin — to verify structured problem/solution reports create proper graph nodes. Tension: with all metadata fields populated.

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.

the knowledge graph is completely empty — no constraints, no vector indexes, no nodes or relationships — After wiping the Neo4j database (AuraDB). Outcome: Running the scripts locally against prod requires leaking credentials.

all reports show "extracted 0 nodes" and the graph stays empty — After wiping Docker volumes for a clean CTF benchmark. Tension: The pg-boss extraction queue processes reports but every write fails. The Neo4j circuit breaker opens after 5 consecutive failures, then stays open permanently. Outcome: The API container logs show the root cause buried deep: `Failed to invoke procedure db.index.vector.queryNodes: There is no such vector schema index: cluster_embedding`.

knowledge reports are completely skipped. Tension: this means hitting bootstrap after adding report support leaves all reports unprocessed in Neo4j. Outcome: structural node only, no semantic extraction via Apollo/Dionysus.

produced noisy entities — verbose Domain definitions, hallucinated concepts, entities that didn't improve search retrieval quality — Knowledge graph extraction pipeline. Tension: No empirical validation: every extracted entity was accepted into the graph regardless of whether it helped agents find relevant content. Outcome: Scattered quality signals (pageRank, effectivenessScore, trustTier) with no unified scoring.

After a successful ETL run and subsequent pageRank/isLandmark steps, `graph_initialize` returns an empty landmarks array. Neo4j contains Problem/RootCause/Solution nodes, but no Pattern nodes and `isLandmark` remains false for all nodes.

generates edge types with spaces — e.g. "REQUIRES Package" instead of "REQUIRES" — During knowledge graph ETL extraction, the Dionysus relation extraction phase (Sonnet) sometimes generates edge types with spaces. Tension: This blocks the entire extraction batch — no edges get written for any pair in the batch. Outcome: Neo4j to throw: `Invalid input 'Package': expected a parameter, '&', '*', ':', 'WHERE', ']', '{' or '|'`. The error is a Neo.ClientError.Statement.SyntaxError (42N32).

A single `typescript` Language node can have 400+ incident edges. — Context nodes in a knowledge graph (Language, Package, OperatingSystem, Paradigm, DataStructure). Tension: The previous workaround was to exclude Context nodes from traversal entirely, which lost them as legitimate grounding/navigation anchors. Outcome: You can't tell an agent "this Problem occurs in Rust" because Rust isn't reachable without also returning 400 unrelated Rust problems.

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.

needed Phase 1 performance and correctness work without bundling unrelated changes — A web graph visualization. Tension: stop automatic full-graph hydration, avoid renderer identity collisions for same-id nodes with different labels/types, order capped edges by salience before limiting, cap WebGL render target cost, and add lightweight performance instrumentation. Outcome: split the work into five independent branches so each change stayed below the requested size budget.

the streamed NDJSON graph feed repeated verbose JSON field names for every node and edge — A graph visualization had two performance issues.

the graph integration functions were stubbed: snapshots always returned zero counts — A benchmark orchestrator wrote before/after graph snapshots and attempted extraction drains. Tension: snapshots always returned zero counts.

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.

[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