VectorPrism

Why dense RAG hallucinates on root-cause questions

Dense RAG is stuck between two bad defaults. Flat cosine over a single embedding returns semantically close chunks that are causally wrong, taxonomically wrong, or temporally expired. Teams call them funny neighbors; production calls them hallucination fuel. That is why root-cause questions — “why did the service fail at 3 AM?” — cite symptom-adjacent text instead of the preceding cause. The second default is multi-vector indexing: one ANN index per representation. Signal improves, but storage and query fan-out on pgvector and Qdrant climb 500% to 1,000%. You need causal retrieval for enterprise RAG without paying multi-vector sticker shock.

Causally wrong neighbors

Flat cosine returns semantically close chunks that are the wrong cause. Symptom-adjacent text looks relevant and becomes hallucination fuel on “why did X fail?” questions.

Taxonomically wrong neighbors

Parent–child trees distort in Euclidean space. A medication chunk sits next to a co-occurring symptom chunk. Hierarchy search needs a hyperbolic channel, not another cosine index.

Expired or unverified chunks

Temporally expired or uncalibrated text still ranks. Multi-vector indexing (one ANN per representation) improves signal but drives 500%–1,000% storage and query fan-out on pgvector / Qdrant.

VectorPrism is built to reduce hallucinations in root-cause RAG by packing six relevance subspaces plus a control header into one 1024d tensor, then gating Stage-2 rescoring on query intent — not by inventing a sixth HNSW index.

pgvector multi-vector cost reduction without six indexes

pgvector multi-vector cost reduction is the storage contract: one vector(1024) (or one named full tensor in Qdrant), Stage-1 HNSW on the generated 368d dense core only, Stage-2 zero-copy slice scoring in RAM. AI SaaS platforms keep multi-signal retrieval at 1× footprint instead of six indexes and six query fans. Optional extras install encoder, postgres, and qdrant adapters; the core pin is pip install "vectorprism==0.1.0".

Dense cosine is not root-cause retrieval. You can keep pgvector or Qdrant as the system of record and still run an intent-gated RAG retrieval engine on top of a single tensor. That is the cost story — not a claim that VectorBridge’s 5.55× migration bandwidth applies here. VectorBridge moves vectors; VectorPrism retrieves them.

How the intent-gated RAG retrieval engine works

The intent-gated RAG retrieval engine is a two-stage search. Ingest freezes a 768d encoder, trains a multi-task adapter, and writes a contiguous 1024d tensor plus a 16d control header. Stage 1 runs HNSW on the 368d dense core only. Stage 2 applies intent weights to rescore causal, hyperbolic taxonomy, relational, and related slices for the top candidates. Stage-1 can gate on packed epistemic truth and anchor distance. Timestamp and model version live in the 16d header for ingest safety; they are not queried as Stage-1 reject filters yet.

01. Ingest into one 1024d tensor

A frozen encoder plus a multi-task adapter writes a contiguous 1024-dimensional tensor and a 16d control header per chunk. Packed fields include bitmask, epistemic truth, anchor distance, timestamp, and model version.

02. Stage-1 HNSW on the dense core

The ANN index touches only the 368d dense semantic core. You keep one vector(1024) / named full tensor in pgvector or Qdrant — not six indexes.

03. Stage-2 intent-gated rescoring

Intent weights rescore causal, hyperbolic taxonomy, relational, and related slices in RAM on the top candidates. Stage-1 can gate on packed truth and anchor distance. Timestamp and model version are packed in the header, not queried as Stage-1 reject filters yet.

Intent routing up-weights the causal channel on “why / cause / reason” queries and the hyperbolic channel on hierarchy intents (“category”, “parent”, “type of”). Serve-time relational scoring is L2 proximity on the relational slice (no query-time relation id yet). Identity is a Stage-1 gate, not a second ANN.

Causal retrieval for enterprise RAG

Causal retrieval for enterprise RAG is the incident-log job. When on-call asks why a node crashed, cosine-only RAG returns symptom neighbors. VectorPrism’s time ODE and directional causality slice is scored with an asymmetric bilinear form so Stage-2 prefers cause→effect order, not merely lexical neighbors. The same engine exposes a hyperbolic taxonomy channel for ontology search. Packed header fields include timestamp and model version for ingest; Stage-1 currently gates on epistemic truth and anchor distance only.

Root-cause / incident logs

“Why did X fail?” returns funny neighbors — close in cosine, wrong as causes.

Causal / time ODE channel up-weighted on why / cause / reason queries.

Taxonomy / ontology search

Hierarchy distorts in Euclidean space; parent–child trees bleed across categories.

Hyperbolic taxonomy channel scored with Poincaré distance in Stage 2.

Compliance / bitemporal

Expired or unverified chunks still rank and get cited.

Packed header stores timestamp and model version for ingest. Stage-1 currently gates on epistemic truth and anchor distance — not timestamp or model_version filters yet.

This is not PrismRAG (taxonomy graph edges and mapping rules) and not PrismCortex (agent memory). Related: PrismRAG · VectorBridge · PrismCortex.

Positional subspace multiplexing vector search — the 1024d memory map

Positional subspace multiplexing vector search is the memory contract: six independently trained relevance subspaces live at fixed offsets in one float32 tensor. Ground truth is PSMTensorContract / VectorPrismTensorContract in the repository. Philosopher channel names appear only as diagram footnotes in the README — the landing story is pain, stages, and cost.

Header packing uses bit-reinterpret for the channel bitmask, int64 timestamp across two float32 slots, and model version so re-ingest after retrains stays safe. Stage-1 HNSW indexes only dense_core [16:384).

Proof (vendor adversarial pack — disclose)

Vendor adversarial finance pack (not a customer SLA). Dense fails on purpose on this labeled pack; multi-channel recovers the misses under the disclosed harness. Full tables, caveats, and reproduce commands live in BENCHMARKS.md and demos/finance_demo/results/. Interactive comparison: demo site.

Synthetic / pre-client labeled pack under a disclosed harness. Production bar = your documents + eval.jsonl. See TECHNICAL_REPORT.md in the repo. Do not read these figures as a live customer SLA or as “always beats dense on every OOD pack.”

Additional README figures on the same pack include auto-graph recovered@10 of 11/13 and 1000-doc scale recovered@10 of 13/13 at about 1.8 ms in-memory. Sub-15ms is a latency target in the README, not a universal SLA. Do not claim VectorPrism always beats dense on every out-of-distribution pack.

Install · pilot · soft RECOVER

Pin pip install "vectorprism==0.1.0". Optional extras: pip install "vectorprism[all]". Then vectorprism pilot-check. Apache-2.0 · Python ≥ 3.10 · vectorprism==0.1.0 · pgvector · Qdrant. Production path (recommended on Windows): Docker Compose against Postgres/pgvector — see PRODUCTION.md and DOCKER.md. Pilot playbook: PILOT.md. PyPI: vectorprism 0.1.0. GitHub: insightitsGit/VectorPrism.

Soft CTA RECOVER — email info@insightits.com?subject=RECOVER. No Calendly. No invented Buy button. OSS Apache-2.0 plus a warm pilot.

Open source for builders. Enterprise, contact us.

VectorPrism is Apache-2.0 open source on GitHub and PyPI — free to install, inspect, and run. Pin pip install "vectorprism==0.1.0". No license key.

For enterprise support, production RAG, pgvector / Qdrant rollout, or a design-partner pilot, contact Insight IT Solutions at info@insightits.com. Subject VectorPrism Enterprise or RECOVER. No Calendly.

FAQ

Does VectorPrism replace VectorBridge?

No. VectorBridge migrates vectors between databases (bandwidth, metric guard, semantic validation). VectorPrism is an intent-gated RAG retrieval engine — positional subspace multiplexing in one 1024d tensor. They are sibling libraries with different jobs.

Does VectorPrism replace PrismRAG?

No. PrismRAG is the taxonomy graph product (explicit mapping rules and graph edges). VectorPrism is multi-channel vector retrieval — Stage-1 HNSW on the dense core, Stage-2 intent-gated rescoring of causal / taxonomy / relational slices. Use them together, not as substitutes.

Does VectorPrism replace PrismCortex?

No. PrismCortex is deterministic bitemporal agent memory. VectorPrism retrieves the right chunks; Cortex remembers and replays. Different layer.

Do I need six pgvector or Qdrant indexes?

No. VectorPrism stores one 1024-dimensional tensor per chunk. Stage-1 HNSW indexes only the 368d dense core. Stage-2 rescored causal / hyperbolic taxonomy / relational channels in RAM at 1× storage — that is the pgvector multi-vector cost reduction.

Is there a universal sub-15ms SLA?

No. Sub-15ms is a README latency target, not a customer SLA. The disclosed 1000-doc adversarial pack measured about 1.8 ms in-memory on that candidate set. Production latency is your corpus, hardware, and eval.jsonl.

Did VectorPrism always beat dense RAG in production?

No. Published numbers are a vendor adversarial finance pack under a disclosed harness — not a live customer SLA and not “always recovers.” Some transfer tables tie or slightly lose. Production bar = your documents + eval.jsonl. See TECHNICAL_REPORT.md in the repo.

How do I install VectorPrism?

pip install "vectorprism==0.1.0" (or pip install "vectorprism[all]"), then vectorprism pilot-check. Apache-2.0, Python ≥ 3.10. On Windows the Docker + pgvector path in PRODUCTION.md / DOCKER.md is recommended. Soft CTA: email info@insightits.com with subject RECOVER.

Is VectorPrism open source? How do enterprises get in touch?

Yes. VectorPrism is Apache-2.0 on GitHub and PyPI — free to install. For enterprise support, pilots, or production RAG, email info@insightits.com (subject VectorPrism Enterprise or RECOVER). No Calendly.

Capabilities

Root-cause / incident logs

“Why did X fail?” — causal / time ODE channel up-weighted on why / cause / reason queries instead of funny cosine neighbors.

Taxonomy / ontology search

Hierarchy distorts in Euclidean space. Hyperbolic taxonomy channel scored with Poincaré distance in Stage 2.

Compliance / bitemporal

Control header packs timestamp and model version for ingest. Stage-1 currently gates on epistemic truth and anchor distance — those two fields are queried; timestamp / model_version are not Stage-1 reject filters yet.

Install

pip install "vectorprism==0.1.0". Optional: pip install "vectorprism[all]". Apache-2.0, Python ≥ 3.10. Soft CTA RECOVER — mailto:info@insightits.com?subject=RECOVER.

Pricing

VectorPrism is Apache-2.0 on PyPI and GitHub — $0 forever. Soft CTA RECOVER: mailto:info@insightits.com?subject=RECOVER. External pilot: PILOT.md. No Calendly.

Frequently asked questions