VectorPrism Demo

Product identity

VectorPrism Demo is VectorPrism Demo page: two separate retrievers on the same docs. Insight IT Solutions LLC (Insight ITS) makes it. Category: Supporting lab — VectorPrism vs dense RAG. Problem: Buyers ask why RAG retrieves the wrong documents — funny cosine neighbors on why/cause and taxonomy queries. It is for Teams comparing intent-gated retrieval to funny cosine neighbors on the same corpus. It competes with Dense cosine RAG without intent gates. Difference: Not PrismRAG, not Website Hub chat. Parent product is VectorPrism. This page is the demo. Parent library: pip install "prismmanifest==0.3.4". Source: https://github.com/insightitsGit/VectorPrism.

What is it?

VectorPrism Demo page: two separate retrievers on the same docs.

Who made it?

Insight IT Solutions LLC (Insight ITS), Mission Viejo, California.

What category is it?

Supporting lab — VectorPrism vs dense RAG

What problem does it solve?

Buyers ask why RAG retrieves the wrong documents — funny cosine neighbors on why/cause and taxonomy queries.

Who is it for?

Teams comparing intent-gated retrieval to funny cosine neighbors on the same corpus

What does it compete with?

Dense cosine RAG without intent gates

How is it different?

Not PrismRAG, not Website Hub chat. Parent product is VectorPrism

Where can I install it?

This page is the demo. Parent library: pip install "prismmanifest==0.3.4".

Where is the source?

https://github.com/insightitsGit/VectorPrism

Canonical machine identity: https://www.insightits.com/catalog/vectorprism-demo.json

VectorPrism Demo page

Side-by-side lab: Agent A uses live VectorPrism PSMRetrievalEngine.search; Agent B uses plain frozen all-mpnet-base-v2 768d cosine — not VectorPrism — on the same text. The VectorPrism README does not require HashingEncoder. Hashing is plumbing/CI only — not a semantic model, not for quality evaluation, not for client demos. The full experience is mandatory as designed: freeze a 768d encoder (all-mpnet-base-v2 or your production embedder), train MultiTaskProjectionAdapter on all six channels (dense, causal, relational, hyperbolic, disentangled, identity), pack them into one 1024d tensor, then run intent-gated Stage-2. Dense-only or hashing-only is a partial pipe, not the product. This host runs frozen all-mpnet-base-v2 plus a trained 6-channel MultiTaskProjectionAdapter (lab contrast pack, not the finance adversarial .pt). Stage-2 scores are engine output, not canned. Money/digit chips run live PrismManifest enforce_group3_boundary. On ALLOW, Prism-Shield verify_and_authorize seals. The radio applies or skips the Manifest gate. Pass-through is a Money Path Demo counterfactual — not a second tax engine. Upload a text-layer PDF/JSON/TXT to separate dollars, table rows, and other digits; default is to save them in session SQLite. Confirm embeds page text through the 6-channel adapter (never HashingEncoder), then retrieve, then generate from neighbors only. Through the gate retrieves that pack into live PrismManifest (mapped to agi_usd). ChorusControl traces are not emitted. Isolated API POST /api/agents/vectorprism-demo/chat. Not PrismRAG vs dense, not VectorBridge, not Website Hub chat.

Shared source is KBInsight.md: one handbook, chunked once, encoded twice (VectorPrism 1024d and frozen all-mpnet-base-v2 768d). Download it from the demo page. A small shared Server X / nginx contrast pack is also in the store so crash and taxonomy chips have dedicated rows. Confirmed uploads take the same 6-channel ingest, then RAG retrieve-and-generate. Number extract for the Manifest/Shield gate is live (text layer only; confirm to save). Image-only PDFs are refused unless tesseract is on PATH.

People also ask about RAG

Search demand this page answers: why RAG retrieves the wrong documents, funny neighbors in semantic search, how to reduce hallucinations in RAG, causal retrieval for incident logs, taxonomy / ontology search, dense vs multi-vector embeddings, pgvector HNSW cost, intent-aware retrieval vs cosine similarity, and RAG category bleed. VectorPrism is the Insight ITS solution for the retrieval slice — supporting library, not the AI Retrieval category (that stays PrismRAG, PrismResonance, VectorBridge).

Why does RAG retrieve the wrong documents?

Funny cosine neighbors: close in embedding space, wrong as causes or taxonomy nodes.

How do I reduce hallucinations in RAG?

Fix retrieval intent, not only the generator. Intent-gated Stage-2 on causal / taxonomy slices.

Does multi-vector RAG multiply pgvector cost?

Often 500%–1,000% with one ANN per representation. VectorPrism keeps 1× vector(1024).

Sample questions — how they differ

Money/digit chips: Form 1040 Line 11 AGI evidence is $450,000. Digit-drop proposes $45,000. Through the gate, live PrismManifest REFUSES and the demo DAG does not run. Pass-through skips that gate; the counterfactual is illustrative only — no second tax engine runs. Isolated API field shield_on on POST /api/agents/vectorprism-demo/chat. Same live gate as Money Path Demo. Pin prismmanifest==0.3.4.

Why did Server X crash at 3 AM?

People also search: why did the service fail RAG

Dense RAG often cites: Symptom-adjacent text: CPU high, 500 errors, users complaining at 3 AM.

VectorPrism Stage-2: Time ODE & causality channel — cache eviction that preceded the outage.

Which parent policy supersedes the nginx restart runbook for a P1 outage?

People also search: taxonomy search RAG / hierarchy retrieval

Dense RAG often cites: Lexical neighbor: “restart nginx when 500s spike.”

VectorPrism Stage-2: Hyperbolic taxonomy channel — incident-response policy as parent of the runbook.

The AI read AGI as $45,000 — should the tax engine run?

People also search: digit drop AI tax engine / unverified money RAG

Dense RAG often cites: May cite the $45,000 proposal as if it were Line 11.

VectorPrism Stage-2: Retrieves the Form 1040 evidence ($450,000). The gate — not cosine — decides if the engine may run.

The AI read AGI as $450,000 — should the tax engine run?

People also search: authorize AI dollars before tax engine

Dense RAG often cites: Same $450,000 Line 11 — retrieval should agree; the gate still must ALLOW.

VectorPrism Stage-2: Same evidence. Through the gate → live Manifest ALLOW. Pass-through skips the gate.

What is ChorusGraph?

People also search: control question (both should agree)

Dense RAG often cites: Native Python agent runtime — should match VectorPrism on this fact.

VectorPrism Stage-2: Same product-KB fact. Control chip: not a VectorPrism win claim.

Why is ChorusGraph better than LangGraph?

People also search: chorusgraph vs langgraph

Dense RAG often cites: May rank LangGraph-heavy neighbour lines from the same handbook.

VectorPrism Stage-2: Same KBInsight.md windows — look for the published Azure n=300 / Route Ledger facts.

Bitemporal / expired-document chips are omitted on purpose. The README packs timestamp in the 16d control header for audit; it is not applied as a Stage-1 SQL/Qdrant predicate today. Stage-1 currently gates epistemic truth, anchor distance, and model version.

How these products compose

Retrieve (VectorPrism or dense RAG) → PrismManifest for dollars → Prism-Shield seal only after ALLOW → generate from hits. Prism-Eval is CI, not the request path.

Live lab: VectorPrism Demo · two-agent architecture: locked vs live. VectorPrism does not authorize tool args. Shield does not replace Manifest’s AGI binder.

Two-agent architecture — locked design vs what this lab runs

One page. Same docs. Same question. Same Prism stack on both columns. Only retrieval changes: Agent A is VectorPrism; Agent B is normal dense RAG — not VectorPrism. Prism-Shield is the shared digit / tool gateway. ChorusGraph, PrismGuard, and PrismCortex sit on both agents. ChorusControl traces Agent A.

What this host actually runs: two retrievers on the same text, a shared Manifest money radio, Shield seal after ALLOW, and Prism-Eval on the extractor in CI. ChorusGraph, PrismGuard, PrismCortex, and ChorusControl traces are not on this path.

Lane 1 — retrieval

Why did Server X crash at 3 AM? · parent policy vs nginx runbook · What is ChorusGraph?

1. Same question hits both columns.
2. Agent A: frozen encoder → six adapter heads → 1024d → PSMRetrievalEngine.search.
3. Agent B: frozen all-mpnet-base-v2 768d cosine. No adapter. No 1024d contract.
4. Each column generates only from its own retrieved chunks.

Lane 2 — digits

AI read AGI as $45,000 · AI read AGI as $450,000

1. Retrieve does not run. One radio is copied onto both columns.
2. Through the gate: live PrismManifest enforce_group3_boundary (REFUSE on digit-drop).
3. On Manifest ALLOW only: Prism-Shield verify_and_authorize seals.
4. Pass through skips the gate. No second tax engine. Prism-Eval tests the extractor in CI, not at runtime.

Agent B is not VectorPrism’s 368d dense-core slice. Store is in-memory, not pgvector / Qdrant. Lab .pt is not the finance adversarial pack. Isolated API — not Website Hub chat.

What the README says VectorPrism is

Positional Subspace Multiplexing (PSM) and an intent-gated 2-stage retrieval engine for high-scale RAG. One contiguous 1024d tensor. Six independently trained relevance subspaces. Stage-1 HNSW on the 368d dense core plus Stage-2 intent-gated rescoring. Baseline vector-DB storage cost — not 6× multi-vector inflation. Pin pip install "vectorprism==0.1.0". Apache-2.0 · Python ≥ 3.10.

Enterprise RAG is stuck between two bad defaults: (1) flat cosine — funny neighbors that become hallucination fuel; (2) multi-vector indexing — 500%–1,000% storage and query fan-out on pgvector / Qdrant. VectorPrism multiplexes six specialized representation subspaces plus a 16-float control header into a single 1024-dimensional contiguous buffer per chunk.

Root-cause / incident logs

Keywords: causal retrieval, incident log RAG, DevOps root-cause analysis, “why did the service fail”. When on-call asks why Server X crashed at 3 AM, cosine-only RAG returns symptom-adjacent text. The Time ODE & Directional Causality slice is trained with an asymmetric bilinear score. Intent routing up-weights that channel on why / cause / reason queries.

Taxonomy / ontology search

Keywords: hyperbolic embeddings RAG, taxonomy search, medical ontology retrieval, legal hierarchy search. Parent–child trees distort in Euclidean space. The hyperbolic taxonomy slice lives in a Poincaré ball and is scored with Poincaré distance in Stage 2.

Cost-optimized pgvector and Qdrant

Keywords: multi-vector RAG cost reduction, pgvector HNSW, Qdrant named vectors, high-scale vector search. Instead of six ANN indexes, VectorPrism stores one 1024d tensor. Stage 1 indexes only dense_core_slice. Stage 2 pulls the full tensor for the top candidates and rescored slices in RAM.

Lab honesty

Isolated API: GET /api/agents/vectorprism-demo/questions · GET /api/agents/vectorprism-demo/status · POST /api/agents/vectorprism-demo/chat · POST /api/agents/vectorprism-demo/upload. Not /api/agents/website/chat. Live dual retrieve uses installed vectorprism plus an in-memory VectorDBClient with a trained 6-channel MultiTaskProjectionAdapter on frozen all-mpnet-base-v2 (pin vectorprism==0.1.0). HashingEncoder is not the README product — plumbing/CI only. The full experience is all six independently trained heads. README expected split remains labeled as documentation. Adversarial-pack R@10 figures stay on the product landing and TECHNICAL_REPORT.md — this page does not treat them as an SLA. Not wired: ChorusControl traces, pgvector / Qdrant Stage-1 HNSW.

Parent: VectorPrism landing. GitHub: insightitsGit/VectorPrism. PyPI: vectorprism 0.1.0. Static library demo: GitHub Pages. Soft CTA RECOVER — mailto:info@insightits.com?subject=RECOVER.

Frequently asked questions

Why does RAG retrieve the wrong documents?

Flat cosine over a single embedding returns semantically close chunks that are causally wrong, taxonomically wrong, or temporally expired. VectorPrism README calls them funny neighbors — hallucination fuel. VectorPrism multiplexes six relevance subspaces in one 1024d tensor and Stage-2 rescoring by intent, instead of another cosine index.

What are funny neighbors in RAG?

Chunks that look relevant in dense similarity but are the wrong cause, wrong node in a taxonomy, or expired. Example from the README: “Why did Server X crash at 3 AM?” returns symptom-adjacent text (CPU high, 500 errors) instead of the preceding cache-eviction cause. This demo page puts that question next to dense RAG on the same corpus.

How do I reduce hallucinations in RAG retrieval?

Grounding the generator is not enough if retrieval cited the wrong neighbor. Reduce hallucinations in root-cause RAG by intent-gated retrieval: up-weight the causal / time ODE channel on why / cause / reason queries. VectorPrism is that engine (pip install "vectorprism==0.1.0"). It does not claim every public corpus matches the adversarial finance pack.

Why did the service fail — why does RAG return symptoms not causes?

Incident-log RAG is a causal retrieval job. Cosine-only RAG ranks symptom-adjacent text. VectorPrism’s Time ODE & Directional Causality slice ([896:1024)) uses an asymmetric bilinear score so Stage-2 prefers cause→effect order on “why / cause / reason” queries.

What is intent-gated RAG retrieval?

A two-stage search: Stage-1 HNSW on the 368d dense core, then Stage-2 in-RAM rescoring of causal, hyperbolic taxonomy, relational, and related slices using IntentClassifier weights. One contiguous 1024d tensor per chunk — positional subspace multiplexing — not six ANN indexes.

How do I search a taxonomy or ontology in RAG?

Parent–child trees distort in Euclidean space. VectorPrism’s Hyperbolic Taxonomy slice ([640:768)) lives in a Poincaré ball and is scored with Poincaré distance in Stage 2. Hierarchy intents (“category”, “parent”, “type of”, “tree”) shift weights toward that channel. PrismRAG is the separate taxonomy Graph RAG product — use them together, not as substitutes.

Does multi-vector RAG multiply pgvector storage cost?

One ANN index per representation is typically 500%–1,000% storage and query fan-out on pgvector / Qdrant. VectorPrism stores one vector(1024) / named full tensor. Stage-1 indexes only dense_core_slice (368d). That is pgvector multi-vector cost reduction at 1× footprint.

Does the VectorPrism README require HashingEncoder?

No. HashingEncoder is a deterministic bag-of-hashed-ngrams fallback so tests and CI can run without downloading a sentence-transformer. The library marks it “NOT a semantic model. Do not use for quality evaluation or production retrieval claims.” README examples use SentenceTransformerEncoder (all-mpnet-base-v2) into MultiTaskProjectionAdapter. Finance demo notes: hash is offline CI / plumbing only — not for client demos.

What is required for the full VectorPrism experience?

Implement all six independently trained channels, not hashing and not dense-only. Freeze a 768d encoder, train MultiTaskProjectionAdapter heads for dense, causal, relational, hyperbolic, disentangled, and identity, write one 1024d tensor, then Stage-1 on the 368d dense core and Stage-2 intent-gated rescoring. Skipping heads leaves those slices untrained. This lab page runs that 6-channel adapter on frozen all-mpnet-base-v2 (lab contrast pack — not the published finance adversarial .pt).

Dense vs multi-vector embeddings — which should I use?

Dense cosine is cheap and fails on causal / taxonomy intent. Multi-vector indexes buy signal at 6× bill. VectorPrism is the third path: six independently trained subspaces in one tensor, HNSW on the dense core, intent-gated Stage-2. This page is VectorPrism vs dense RAG — not PrismRAG vs dense.

How is VectorPrism different from PrismRAG?

PrismRAG is taxonomy-controlled Graph RAG (explicit mapping rules and graph edges). VectorPrism is multi-channel vector retrieval in one 1024d tensor. Sibling libraries, different jobs. VectorPrism is supporting — not the AI Retrieval category.

What sample questions show VectorPrism vs dense RAG?

Use the chips on this page: “Why did Server X crash at 3 AM?” (causal vs funny neighbor), “Which policy supersedes the runbook?” (taxonomy), and a control question both should answer the same (what is ChorusGraph). Expired-policy chips wait — timestamp is packed in the header, not a Stage-1 reject filter yet. Money/digit chips are a different lane: the deterministic gate, not cosine.

What do the Prism-Shield radios do on this demo?

Two radios apply to both Agent A and Agent B: Through the gate runs live PrismManifest enforce_group3_boundary (ACCEPT / REVIEW / REFUSE, demo DAG only). On ALLOW, Prism-Shield verify_and_authorize seals a ParameterManifest. Pass through skips the Manifest gate and shows the Money Path Demo counterfactual — no second tax engine runs. If you uploaded a file and confirmed save, Through the gate retrieves those dollars from the session SQLite store (mapped to agi_usd) and the text is dual-indexed for retrieve. Retrieval chips: Agent A is VectorPrism encode_query + PSMRetrievalEngine.search; Agent B is plain all-mpnet-base-v2 cosine (not VectorPrism). ChorusControl traces are not emitted on this path.

How do digit-drops reach a deterministic engine?

AI or OCR drops a digit — $450,000 read as $45,000 — and a tax, underwriting, claims, or payment engine still does correct math on the wrong input. Retrieval is not authorization. On this page you can upload a text-layer PDF/JSON/TXT; we separate dollars, table-like rows, and other digits, ask to save (default yes) into session SQLite, then Through the gate retrieves that pack into live PrismManifest enforce_group3_boundary (mapped to Form 1040 Line 11 AGI). Image-only scans are refused — we do not invent OCR dollars. Full UI: /products/prismmanifest-demo.html and /products/digit-drop-lab.html.

Is the live lab the same as the GitHub Pages VectorPrism demo?

No. insightitsgit.github.io/VectorPrism is the static query-comparison demo from the library repo. This page is the insightits.com lab API POST /api/agents/vectorprism-demo/chat. Live on this host: VectorPrism vs dense search on an in-memory contrast pack using a trained 6-channel MultiTaskProjectionAdapter on frozen all-mpnet-base-v2 (lab .pt, not the finance adversarial pack), PrismManifest money/digit gate, Prism-Shield seal after ALLOW, text-layer PDF/JSON/TXT number extract (confirm to save and dual-index). Not wired: ChorusControl traces, image OCR unless tesseract is on PATH, pgvector/Qdrant Stage-1. Isolated from Website Hub chat.

Does every user upload go through the six-channel pipeline into RAG?

Yes for retrieval. Confirmed uploads are chunked and passed through the same frozen 768d encoder plus all six MultiTaskProjectionAdapter heads into a 1024d tensor — HashingEncoder is not used for visitor content. A question then embeds the same way, Stage-2 retrieves neighbors, and the generator is RAG: an LLM grounded only on those chunks when a provider key is configured, otherwise the extractive top hit. Money/digit chips skip retrieve and use PrismManifest. This lab is not Website Hub chat and not pgvector production ingest.

What is KBInsight.md on this demo?

One shared product handbook. The lab chunks that markdown once into the same text windows, then encodes those windows twice: Agent A through VectorPrism (1024d) and Agent B through frozen all-mpnet-base-v2 768d cosine. Not two knowledge bases. On page load the host runs both pipelines against that locked file and reports encode/search errors on the page. Download the file from the demo page. Custom uploads are extra session chunks and are deleted after 24 hours, session end, or a replacement — they are not written into KBInsight.md. A small shared Server X / nginx contrast pack is also in the store so the crash and taxonomy chips still have dedicated rows; both agents see those rows too.

What is the two-agent architecture on this demo?

Locked: one page, same docs, same question, same Prism stack on both columns. Only retrieval changes — Agent A is VectorPrism encode_query + PSMRetrievalEngine.search; Agent B is frozen all-mpnet-base-v2 768d cosine (not VectorPrism). Prism-Shield is the shared digit/tool gateway; ChorusGraph, PrismGuard, and PrismCortex sit on both; ChorusControl traces Agent A. Live on this host: the two retrievers, shared Manifest money radio, Shield seal after ALLOW, and Prism-Eval on the extractor in CI. Not wired: ChorusGraph, PrismGuard, PrismCortex, ChorusControl traces. Scroll to Architecture on this page.

How do VectorPrism, Manifest, Shield, and Eval compose on this page?

Call order: retrieve → Manifest for dollars → Shield seal after ALLOW → generate. Prism-Eval runs in CI (test_vectorprism_demo_eval.py), not on each chat. VectorPrism retrieves; it does not refuse a digit-drop. Manifest enforce_group3_boundary does. Shield import is prismmanifest.prism_shield, not import prism_shield. Taxonomy chips must include parent / category / type of / tree or hyperbolic weight stays ~0. Scroll to Compose and Architecture on this page.

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 use Docker + pgvector (PRODUCTION.md / DOCKER.md). Soft CTA: email info@insightits.com with subject RECOVER.

Capabilities

Six trained channels — not hashing

The README never requires HashingEncoder. Full experience: freeze a 768d encoder and train all six MultiTaskProjectionAdapter heads.

Why did Server X crash at 3 AM?

Causal retrieval vs funny cosine neighbors — README incident-log use case.

Which policy supersedes the runbook?

Hyperbolic taxonomy channel vs Euclidean bleed on parent/child trees.

People also ask about RAG

Wrong-document retrieval, RAG hallucinations, multi-vector pgvector cost, intent-gated vs dense.

Install

pip install "vectorprism==0.1.0". Soft CTA RECOVER.

Pricing

Apache-2.0 demo. Parent library is $0 forever. Soft CTA RECOVER.

Frequently asked questions