Enterprise RAG Architecture in 2026

NAIVE RAG PIPELINE (The Fragile Prototype Pattern)
[PDFs / Docs] ──► [Chunk every 500 chars] ──► [OpenAI text-embedding-ada-002] ──► [Pinecone DB]
                                                                                       │
[User Query]  ──────────────────────────────────► [Top-5 Cosine Match] ◄───────────────┘
                                                         │
                                                         ▼
                                       [Injected into LLM Prompt]
                                                         │
                                                         ▼
                                [HALLUCINATION / CONTRADICTION]

┌────────────────────────────────────────────────────────────────────────┐
│               THE KAAMLABS source-grounded RAG PIPELINE             │
└──────────────────────────────────┬─────────────────────────────────────┘
                                   │
      ┌────────────────────────────┴────────────────────────────┐
      ▼                                                         ▼
[STAGE 1: DOCUMENT HYGIENE]                               [STAGE 2: HYBRID DENSE/SPARSE SEARCH]
• Parse structural Markdown & Tables                      • Sparse Search: BM25 / tsvector (Exact keywords)
• Inject document hierarchy breadcrumbs                   • Dense Search: HNSW Cosine Similarity (Semantic intent)
• Compute parent-child chunk relations                    • Fusion: Reciprocal Rank Fusion (RRF) -> Top 30 candidates
                                                                │
                                                                ▼
                                                          [STAGE 3: CROSS-ENCODER RE-RANKING]
                                                          • Deep multi-pass semantic relevance scoring
                                                          • Filter candidate pool from 30 down to Top 3 chunks
                                                                │
                                                                ▼
                                                          [STAGE 4: STRICT PROMPT CONFINEMENT]
                                                          • System instruction: Ground strictly in context
                                                          • Fallback trigger if confidence < 90%
                                                                │
                                                                ▼
                                                          [STAGE 5: CITATION INGESTION & AUDIT]
                                                          • Every sentence tagged with source document & page

DEDICATED VECTOR DB (Distributed State Friction)
[PostgreSQL (Users, Auth, Orders)] ◄── Sync Queue (Kafka/Debezium) ──► [Pinecone (Embeddings)]
• Dual database operations
• Eventual consistency lag
• Dual backup schedules
• Vulnerable to orphaned vector records

UNIFIED POSTGRESQL + PGVECTOR (ACID Consistency & Zero Sync Lag)
┌────────────────────────────────────────────────────────────────────────┐
│ POSTGRESQL DATABASE (Single Source of Truth)                           │
│ • relational_tables (Users, RBAC permissions, Orders, Invoices)        │
│ • knowledge_chunks (id, content, metadata, embedding vector(1536))     │
│ • HNSW Index (Sub-10ms Cosine Distance Search)                         │
│ • Full ACID transactions: Delete document = vectors deleted instantly  │
│ • Built-in Row-Level Security (RLS) handles document auth natively    │
└────────────────────────────────────────────────────────────────────────┘

User Query: "What is the peak pressure rating for Flange Model F-8402 under ASTM A105?"

Dense Semantic Search (HNSW Cosine):
1. [Rank 1]: General pressure calculations for carbon steel flanges. (Score: 0.88)
2. [Rank 2]: F-8402 Flange technical specifications. (Score: 0.86)
3. [Rank 3]: ASTM A105 material properties overview. (Score: 0.84)

Sparse Keyword Search (PostgreSQL tsvector / BM25):
1. [Rank 1]: F-8402 Flange technical specifications. (Matched exact token "F-8402")
2. [Rank 2]: Replacement gaskets for F-8402. (Matched exact token "F-8402")
3. [Rank 3]: ASTM A105 carbon steel pressure tables. (Matched exact token "ASTM A105")

Reciprocal Rank Fusion (RRF) Algorithm:
RRF_Score(d) = Σ [ 1 / (60 + Rank_dense(d)) ] + [ 1 / (60 + Rank_sparse(d)) ]

Fused Winner:
-> Chunk: "F-8402 Flange technical specifications" achieves highest composite rank!

[Candidate Chunks from Hybrid Search: Top 30]
                       │
                       ▼
┌────────────────────────────────────────────────────────┐
│ CROSS-ENCODER RE-RANKING MODEL (Cohere / BGE-Reranker) │
│ • Joint token attention: Query <-> Document Passage     │
│ • Evaluates nuance, negation, and specific condition   │
│ • Re-scores candidates on 0.00 - 1.00 relevance scale  │
└──────────────────────┬─────────────────────────────────┘
                       │
                       ▼
[Top 3 Gold-Standard Chunks Injected into Prompt Context]

-- Enable the vector extension
CREATE EXTENSION IF NOT EXISTS vector;

-- Table: Knowledge Documents
CREATE TABLE enterprise_documents (
    id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
    title VARCHAR(255) NOT NULL,
    department VARCHAR(64) NOT NULL,
    access_role VARCHAR(32) NOT NULL DEFAULT 'EMPLOYEE',
    source_url TEXT,
    created_at TIMESTAMPTZ DEFAULT NOW()
);

-- Table: Semantic Knowledge Chunks
CREATE TABLE document_chunks (
    id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
    document_id UUID REFERENCES enterprise_documents(id) ON DELETE CASCADE,
    chunk_index INT NOT NULL,
    breadcrumb_path TEXT NOT NULL,
    content TEXT NOT NULL,
    tsv_content TSVECTOR GENERATED ALWAYS AS (to_tsvector('english', content)) STORED,
    embedding VECTOR(1536) NOT NULL,
    metadata JSONB DEFAULT '{}'::jsonB,
    created_at TIMESTAMPTZ DEFAULT NOW()
);

-- 1. Full-text search index (Sparse BM25 equivalent)
CREATE INDEX idx_chunks_tsv ON document_chunks USING GIN(tsv_content);

-- 2. HNSW Vector Index for measured cosine distance search
-- m=16, ef_construction=64 provides the optimal balance of build speed and 98%+ recall
CREATE INDEX idx_chunks_hnsw_embedding ON document_chunks 
USING hnsw (embedding vector_cosine_ops) 
WITH (m = 16, ef_construction = 64);

// lib/hybridRagRetrieval.ts
import { Pool } from 'pg';
import { OpenAI } from 'openai';
import { CohereClient } from 'cohere-ai';

const db = new Pool({ connectionString: process.env.DATABASE_URL });
const openai = new OpenAI({ apiKey: process.env.OPENAI_API_KEY });
const cohere = new CohereClient({ token: process.env.COHERE_API_KEY });

interface RetrievedChunk {
  id: string;
  content: string;
  breadcrumb: string;
  sourceUrl: string;
}

export async function executeProductionHybridRAG(
  query: string,
  userRole: string
): Promise<RetrievedChunk[]> {
  // 1. Generate query embedding vector
  const embeddingResponse = await openai.embeddings.create({
    model: 'text-embedding-3-small',
    input: query,
  });
  const vectorStr = `[${embeddingResponse.data[0].embedding.join(',')}]`;

  // 2. Execute Hybrid Search (Dense HNSW + Sparse Fulltext) in PostgreSQL
  const hybridQuery = `
    WITH dense_search AS (
      SELECT c.id, c.content, c.breadcrumb_path, d.source_url,
             ROW_NUMBER() OVER (ORDER BY c.embedding <=> $1::vector) as dense_rank
      FROM document_chunks c
      JOIN enterprise_documents d ON c.document_id = d.id
      WHERE d.access_role = $2 OR $2 = 'ADMIN'
      LIMIT 25
    ),
    sparse_search AS (
      SELECT c.id, c.content, c.breadcrumb_path, d.source_url,
             ROW_NUMBER() OVER (ORDER BY ts_rank_cd(c.tsv_content, plainto_tsquery('english', $3)) DESC) as sparse_rank
      FROM document_chunks c
      JOIN enterprise_documents d ON c.document_id = d.id
      WHERE c.tsv_content @@ plainto_tsquery('english', $3)
        AND (d.access_role = $2 OR $2 = 'ADMIN')
      LIMIT 25
    )
    SELECT 
      COALESCE(d.id, s.id) as id,
      COALESCE(d.content, s.content) as content,
      COALESCE(d.breadcrumb_path, s.breadcrumb_path) as breadcrumb,
      COALESCE(d.source_url, s.source_url) as source_url,
      (COALESCE(1.0 / (60 + d.dense_rank), 0.0) + COALESCE(1.0 / (60 + s.sparse_rank), 0.0)) as rrf_score
    FROM dense_search d
    FULL OUTER JOIN sparse_search s ON d.id = s.id
    ORDER BY rrf_score DESC
    LIMIT 20;
  `;

  const { rows } = await db.query(hybridQuery, [vectorStr, userRole, query]);

  if (rows.length === 0) return [];

  // 3. Cross-Encoder Re-Ranking using Cohere Rerank v3
  const reranked = await cohere.v2.rerank({
    model: 'rerank-v3.5',
    query: query,
    documents: rows.map((r: any) => `${r.breadcrumb}\n${r.content}`),
    topN: 3,
  });

  // 4. Return top 3 verified chunks
  return reranked.results.map((res) => rows[res.index]);
}

-- Enable Row-Level Security on document tables
ALTER TABLE enterprise_documents ENABLE ROW LEVEL SECURITY;
ALTER TABLE document_chunks ENABLE ROW LEVEL SECURITY;

-- Create security policy: Users can only select documents matching their department or role
CREATE POLICY tenant_isolation_policy ON enterprise_documents
FOR SELECT
TO authenticated_app_user
USING (
    department = current_setting('app.current_department', true)
    OR access_role = 'PUBLIC'
);