script.js

const ragData = [
    {
        type: "Naive RAG",
        year: 2020,
        category: "Foundational",
        indexing: "Preprocessing → Fixed Chunking → Simple Embedding → Vector DB Storage",
        inference: "User Query → Embedding → Vector DB Lookup (Top-K) → Concatenation → LLM Generate",
        benefits: "Establishes the knowledge retrieval baseline; Simple and cheap to implement.",
        challenges: "Context loss due to rigid chunking; High hallucination risk; Poor handling of complex/multi-step queries.",
        references: "Lewis, P., et al. (2020). Retrieval-Augmented Generation for Knowledge-Intensive NLP Tasks. NeurIPS 2020.",
        paperUrl: "https://arxiv.org/abs/2005.11401"
    },
    {
        type: "Self RAG",
        year: 2023,
        category: "Agentic & Modular",
        indexing: "Preprocessing → Standard Chunking → Embedding → Vector DB Storage",
        inference: "User Query → LLM Generates a thought → Retrieval → LLM Generates/Evaluates Retrieved Passages → LLM Decides if Answer is Ready → Final LLM Generate",
        benefits: "Reduces hallucinations by self-critique/verification; Filters out poor quality retrieved passages.",
        challenges: "Increases inference latency (multiple LLM calls per query); Requires careful tuning of reflection/critique prompt.",
        references: "Asai, A., et al. (2023). Self-RAG: Learning to Retrieve, Generate, and Critique through Self-Reflection. arXiv:2310.11511",
        paperUrl: "https://arxiv.org/abs/2310.11511"
    },
    {
        type: "Modular RAG",
        year: 2024,
        category: "Modular",
        indexing: "Preprocessing → Standard Chunking → Embedding → Vector DB Storage",
        inference: "User Query → Router/Module Selection → Selected Module Executes → LLM Generate",
        benefits: "Improves flexibility and component reusability; Enables optimal module selection for specific tasks.",
        challenges: "Requires complex routing/planning logic; Overhead of training/managing multiple specialized components.",
        references: "Gao, Y., et al. (2024). Modular RAG: Transforming RAG Systems into LEGO-like Reconfigurable Frameworks. arXiv:2407.21059",
        paperUrl: "https://arxiv.org/abs/2407.21059"
    },
    {
        type: "Cache RAG",
        year: 2024,
        category: "Modular",
        indexing: "Preprocessing → Standard Chunking → Embedding → Vector DB Storage",
        inference: "User Query → Cache Lookup → If Hit: Return Cached Answer → If Miss: Standard Retrieval → LLM Generate → Cache Store",
        benefits: "Dramatically improves latency and reduces LLM cost for repeated or highly similar queries.",
        challenges: "Complex cache invalidation logic; Requires robust query similarity and hashing functions.",
        references: "Jin, C., et al. (2024). RAGCache: Efficient Knowledge Caching for Retrieval-Augmented Generation. ACM TOCS.",
        paperUrl: "https://arxiv.org/abs/2404.12457"
    },
    {
        type: "MultiModal RAG",
        year: 2024,
        category: "Structural",
        indexing: "Preprocessing → Multi-Modal Embedding (e.g., CLIP) → Stores representations of all modalities in Vector DB",
        inference: "User Query (Text or Image) → Multi-Modal Embedding → Vector DB Lookup (Retrieves related text, image, metadata) → LLM Generate",
        benefits: "Unlocks knowledge stored in non-text data (images, charts, tables); Provides a richer context.",
        challenges: "Requires specialized multimodal embeddings/models; Indexing is computationally expensive; Difficult to combine disparate modalities coherently.",
        references: "Gao, Y., et al. (2024). Retrieval-Augmented Multimodal Language Modeling. CVPR 2024.",
        paperUrl: "https://arxiv.org/abs/2211.12561"
    },
    {
        type: "Graph RAG",
        year: 2024,
        category: "Structural & Modular",
        indexing: "Preprocessing → Entity/Relation Extraction → Store in Knowledge Graph (KG) & Vector DB",
        inference: "User Query → Embedding/KG Query → Simultaneous Retrieval (Vector + KG Path) → Concatenation → LLM Generate",
        benefits: "Resolves complex, multi-hop queries by leveraging factual relationships; Improves interpretability and fact consistency.",
        challenges: "High indexing complexity (KG construction); Expensive maintenance for rapidly changing data; Retrieval latency can be high.",
        references: "Barry, M., et al. (2025). GraphRAG: Leveraging Graph-Based Efficiency to Minimize Hallucinations in LLM-Driven RAG. GenAIK Workshop.",
        paperUrl: "https://aclanthology.org/2025.genaik-1.6/"
    },
    {
        type: "Recursive RAG",
        year: 2024,
        category: "Structural & Modular",
        indexing: "Preprocessing → Chunking & Summarization → Embeddings of both chunks & summaries → Vector DB Storage",
        inference: "User Query → Retrieval → LLM evaluates initial result → Recursive Query → Retrieve Specific Chunks → LLM Generate",
        benefits: "Summarizes context or decomposes queries recursively; Handles high-level questions that require abstract understanding.",
        challenges: "Risk of information loss during aggressive summarization; Chain of thought adds significant latency.",
        references: "Liu, Y., et al. (2024). RAG-GPT: Retrieval-Augmented Generation for Open-Domain Question Answering. IJCNN 2024.",
        paperUrl: "https://arxiv.org/abs/2405.10627"
    },
    {
        type: "Multi-Hop RAG",
        year: 2024,
        category: "Structural & Modular",
        indexing: "Preprocessing → Chunking/Entity Extraction → Embedding → Structured Storage (Vector DB + Optional KG)",
        inference: "User Query → Query Decomposition → Hop 1 Retrieval → Iterative Reasoning → Hop 2 Retrieval → Final Evidence Aggregation → LLM Generate",
        benefits: "Solves questions requiring reasoning across multiple independent documents or retrieval steps.",
        challenges: "Prone to error propagation (if one hop fails); Significantly higher latency; Requires generation of accurate intermediate queries.",
        references: "Tang, B., & Yang, Y. (2024). MultiHop-RAG: Benchmarking Retrieval-Augmented Generation for Multi-Hop Queries. COLM 2024.",
        paperUrl: "https://arxiv.org/abs/2401.15391"
    },
    {
        type: "Corrective RAG",
        year: 2024,
        category: "Agentic & Modular",
        indexing: "Preprocessing → Standard Chunking → Embedding → Vector DB Storage",
        inference: "User Query → Standard Retrieval → Retrieved Docs Evaluated → Corrective Action → LLM Generate",
        benefits: "Detects and corrects poor quality retrieval/generation post-hoc; Increases overall trustworthiness.",
        challenges: "High latency due to iterative correction loops; Requires training a dedicated evaluation model.",
        references: "Yan, S.-Q., et al. (2024). Corrective Retrieval Augmented Generation. arXiv:2401.15884",
        paperUrl: "https://arxiv.org/abs/2401.15884"
    },
    {
        type: "Agentic RAG",
        year: 2024,
        category: "Agentic & Modular",
        indexing: "Preprocessing → Standard Chunking → Embedding → Vector DB Storage",
        inference: "User Query → Agent Planning/Tool Selection → Agent Executes RAG Retrieval → Agent Reflects/Synthesizes → Final LLM Generate",
        benefits: "Handles complex, goal-oriented tasks via dynamic planning, tool use, and state tracking.",
        challenges: "Highest development/orchestration complexity; Slowest inference due to planning/execution loops; Failure in planning leads to catastrophic task failure.",
        references: "Singh, A., et al. (2025). Agentic Retrieval-Augmented Generation: A Survey on Agentic RAG.",
        paperUrl: "https://arxiv.org/abs/2412.09550"
    },
    {
        type: "Adaptive RAG",
        year: 2024,
        category: "Agentic & Modular",
        indexing: "Preprocessing → Standard Chunking → Embedding → Vector DB Storage → Train Query Complexity Classifier",
        inference: "User Query → Query Classification (Router) → Adaptive Decision → Retrieval Execution → LLM Generate",
        benefits: "Optimizes pipeline complexity and cost based on query assessment.",
        challenges: "Requires training a robust query classifier/router; Misclassification can lead to poor quality results.",
        references: "Jeong, S., et al. (2024). Adaptive-RAG: Learning to Adapt Retrieval-Augmented Large Language Models through Question Complexity. NAACL 2024.",
        paperUrl: "https://arxiv.org/abs/2403.14403"
    },
    {
        type: "Hierarchical RAG",
        year: 2025,
        category: "Structural & Modular",
        indexing: "Preprocessing → Hierarchical Chunking (Multiple levels) → Multiple Embeddings (for each level) → Vector DB Storage",
        inference: "User Query → Embedding → Multi-Level Retrieval → Concatenation → LLM Generate",
        benefits: "Solves the 'needle-in-a-haystack' problem for very long documents; Efficiently prunes non-relevant sections.",
        challenges: "Complex, multi-level chunking and indexing structure; Requires multiple retrieval passes.",
        references: "Huang, H., et al. (2025). Retrieval-Augmented Generation with Hierarchical Knowledge (HiRAG). EMNLP 2025.",
        paperUrl: "https://aclanthology.org/2025.emnlp-main.1/"
    },
    {
        type: "Speculative RAG",
        year: 2025,
        category: "Modular",
        indexing: "Preprocessing → Standard Chunking → Embedding → Vector DB Storage",
        inference: "User Query → Standard Retrieval → Drafting LLM Generates Tokens → Verifier LLM Checks Drafted Tokens Against Context → LLM Generate",
        benefits: "Significantly reduces token generation latency and LLM inference cost.",
        challenges: "Does not inherently improve semantic quality or hallucination rate; Requires careful balance between drafting and verifier models.",
        references: "Wang, Z., et al. (2025). Speculative RAG: Enhancing Retrieval Augmented Generation through Drafting. ICLR 2025.",
        paperUrl: "https://arxiv.org/abs/2407.08223"
    }
];

const chunkingData = [
    {
        type: "Sliding Window Chunking",
        year: 1998,
        category: "Size-based",
        workflow: "Input Document → Define Chunk Size & Overlap → Slide Window (e.g., size 300, overlap 100) → Create Overlapping Chunks → Output Chunks",
        description: "Uses a fixed chunk size plus overlap (e.g., chunk size 300, overlap 100). Maintains context continuity across chunks.",
        references: "Carbonell, J. & Goldstein, J. (1998). The use of MMR, diversity-based reranking for reordering documents. SIGIR 1998.",
        paperUrl: "https://dl.acm.org/doi/10.1145/290941.291025"
    },   
    {
        type: "Fixed-size Chunking",
        year: 2001,
        category: "Size-based",
        workflow: "Input Document → Define Token/Word Limit → Split Text at Limit → Create Fixed Chunks → Output Chunks",
        description: "Splits text into chunks based on a fixed number of tokens/words (e.g., 200-500 tokens). Simple but may break semantic boundaries.",
        references: "Collobert, R., et al. (2011). Natural language processing (almost) from scratch. Journal of Machine Learning Research 12:2493-2537.",
        paperUrl: "https://www.jmlr.org/papers/volume12/collobert11a/collobert11a.pdf"
    },
    {
        type: "Discourse-aware Chunking",
        year: 2005,
        category: "Semantic-based",
        workflow: "Input Document → Identify Discourse Markers (however, in contrast, therefore) → Detect Conceptual Shifts → Split at Discourse Boundaries → Output Discourse Chunks",
        description: "Uses discourse markers (e.g., 'however', 'in contrast', 'therefore') to detect conceptual shifts and chunk accordingly.",
        references: "Sporleder, C. & Lapata, M. (2005). Discourse Chunking and its Application to Sentence Compression. HLT 2005.",
        paperUrl: "https://aclanthology.org/H05-1033/"
    },
    {
        type: "Paragraph-based Chunking",
        year: 2014,
        category: "Structure-based",
        workflow: "Input Document → Identify Paragraph Boundaries → Split at Paragraphs → Create Paragraph Chunks → Output Chunks",
        description: "Uses natural paragraph boundaries for chunking. Preserves document structure and thematic grouping.",
        references: "Dudhabaware, R. S., et al. (2014). Review on natural language processing tasks for text documents. IEEE ICCIC 2014.",
        paperUrl: "https://ieeexplore.ieee.org/document/7238334"
    },
    {
        type: "Recursive/Hierarchical Chunking",
        year: 2023,
        category: "Hierarchical",
        workflow: "Input Document → Break into Sections → Split Sections into Paragraphs → Split Paragraphs into Sentences → Split Sentences into Tokens → Output Multi-level Chunks",
        description: "Breaks document into progressively smaller units (section → paragraph → sentence → tokens). Enables multi-level retrieval.",
        references: "Latif, S., et al. (2025). The Chunking Paradigm: Recursive Semantic for RAG. ICNLSP 2025.",
        paperUrl: "https://aclanthology.org/2025.icnlsp-1.16/"
    },
    {
        type: "Semantic Chunking",
        year: 2024,
        category: "Semantic-based",
        workflow: "Input Document → Analyze Topic Shifts/Semantic Boundaries → Split at Semantic Breaks → Create Semantically Coherent Chunks → Output Chunks",
        description: "Chunks based on topic shifts or semantic boundaries rather than size. Preserves meaning and context.",
        references: "LangChain (2024). Semantic chunker. Accessed 2024-09-14.",
        paperUrl: "https://python.langchain.com/docs/how_to/semantic-chunker/"
    },
    {
        type: "Sentence-based Chunking",
        year: 2024,
        category: "Structure-based",
        workflow: "Input Document → Split by Sentences → Group Sentences (Optional) → Create Sentence Chunks → Output Chunks",
        description: "Splits text by sentences. Maintains grammatical integrity and natural language boundaries.",
        references: "Dong, K., et al. (2024). Multi-view content-aware indexing for long document retrieval. arXiv:2404.15103",
        paperUrl: "https://arxiv.org/abs/2404.15103"
    },
    {
        type: "Hybrid Chunking",
        year: 2024,
        category: "Semantic-based",
        workflow: "Input Document → Apply Semantic Analysis → Apply Fixed-size Constraint → Apply Overlap Strategy → Create Hybrid Chunks → Output Chunks",
        description: "Combines semantic + fixed-size + overlap strategies. Balances context preservation with practical constraints.",
        references: "Kamradt, G. (2024). 5 levels of text splitting.",
        paperUrl: ""
    },
    {
        type: "Embedding-similarity-based Chunking",
        year: 2024,
        category: "Semantic-based",
        workflow: "Input Document → Generate Sentence Embeddings → Calculate Similarity Scores → Detect Similarity Drops Below Threshold → Split at Low Similarity Points → Output Chunks",
        description: "Sequentially processes text and opens a new chunk when embedding similarity drops below a threshold. Data-driven approach.",
        references: "Kamradt, G. (2024). 5 levels of text splitting.",
        paperUrl: ""
    },
    {
        type: "Page-based Chunking",
        year: 2024,
        category: "Structure-based",
        workflow: "Input PDF/Scanned Document → Identify Page Boundaries → Split by Page → Create Page Chunks → Output Chunks",
        description: "Splits by PDF page or scanned document page. Useful for document-level retrieval and citation.",
        references: "",
        paperUrl: ""
    },
    {
        type: "Domain-specific Chunking",
        year: 2024,
        category: "Domain-specific",
        workflow: "Input Domain Document → Apply Domain Rules (legal sections, medical records, code functions) → Split by Domain Logic → Create Domain Chunks → Output Chunks",
        description: "Tailored to content type (e.g., legal documents by sections, medical records by encounters, code by functions).",
        references: "Allamraju, A., et al. (2024). Breaking It Down: Domain-Aware Semantic Segmentation for Retrieval Augmented Generation. arXiv:2512.00367",
        paperUrl: "https://arxiv.org/abs/2512.00367"
    },
    {
        type: "Metadata-based Chunking",
        year: 2025,
        category: "Structure-based",
        workflow: "Input Document → Extract Metadata (headers, bullets, sections) → Split Using Metadata Structure → Create Metadata-aware Chunks → Output Chunks",
        description: "Splits text using document metadata (e.g., headers, bullets). Preserves document structure and hierarchy.",
        references: "Zhao, J., et al. (2025). MoC: Mixtures of Text Chunking Learners for Retrieval-Augmented Generation. ACL 2025.",
        paperUrl: "https://aclanthology.org/2025.acl-long.1/"
    }
];

const chunkingCategoryBriefs = {
    'Size-based': 'Chunks text by fixed sizes or overlapping windows. Simple, predictable, but may break context.',
    'Semantic-based': 'Identifies meaning, topics, or discourse patterns to create contextually coherent chunks.',
    'Structure-based': 'Uses natural document structure (sentences, paragraphs, metadata) for boundaries.',
    'Hierarchical': 'Creates multi-level chunks (sections → paragraphs → sentences) for flexible retrieval.',
    'Domain-specific': 'Applies domain knowledge and rules tailored to specific content types (legal, medical, code).'
};

const mainCategoryDefinitions = {
    'Foundational': 'The baseline RAG approach establishing core retrieval-augmented generation principles with simple, fixed pipelines.',
    'Modular': 'Focuses on pipeline flexibility through specialized, interchangeable components and intermediate operations between query and generation.',
    'Agentic': 'Uses dynamic decision-makers (agents or classifiers) to guide the pipeline, perform self-correction, and enable adaptive behavior.',
    'Structural': 'Innovations in how source documents are preprocessed, stored, and indexed for more effective retrieval (e.g., knowledge graphs, hierarchies, multi-modal embeddings).'
};

function getCategoryBadgeClass(category) {
    if (category.includes('Foundational')) return 'badge-foundational';
    if (category.includes('Agentic')) return 'badge-agentic';
    if (category.includes('Modular')) return 'badge-modular';
    if (category.includes('Structural')) return 'badge-structural';
    return 'badge-modular';
}

function createFlowchart(workflow, containerId) {
    const container = document.getElementById(containerId);
    container.innerHTML = '';
    const steps = workflow.split(' → ');
    steps.forEach((step, index) => {
        const div = document.createElement('div');
        div.className = 'flow-step';
        div.textContent = step;
        container.appendChild(div);
    });
}

// Shared Header and Navigation Injection
function injectHeader() {
    const headerHTML = `
        <h1>🔍 RAG Types and Phases Suvery Dashboard</h1>
        <div class="tabs">
            <a href="index.html" class="tab" data-page="index.html">RAG Types</a>
            <a href="chunking.html" class="tab" data-page="chunking.html">Chunking</a>
            <a href="indexing.html" class="tab" data-page="indexing.html">Indexing & Vector DB</a>
            <a href="augmentation.html" class="tab" data-page="augmentation.html">Augmentation</a>
        </div>
    `;
    
    const container = document.getElementById('shared-header');
    if (container) {
        container.innerHTML = headerHTML;
        
        // Set active tab based on current filename
        const currentPage = window.location.pathname.split('/').pop() || 'index.html';
        const tabs = container.querySelectorAll('.tab');
        tabs.forEach(tab => {
            if (tab.getAttribute('data-page') === currentPage) {
                tab.classList.add('active');
            }
        });
    }
}

// Initialize header on load
window.addEventListener('DOMContentLoaded', injectHeader);
// SOLUTION 1: Use mermaid.render() for dynamic content (Recommended)
async function renderDynamicDiagram(mermaidCode, containerId) {
    const container = document.getElementById(containerId);
    
    // Clear previous
    container.innerHTML = '';
    container.removeAttribute('data-processed'); // Critical: remove mermaid's "done" marker
    
    // Generate unique ID for this render
    const uniqueId = `mermaid-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
    
    try {
        const { svg } = await mermaid.render(uniqueId, mermaidCode);
        container.innerHTML = svg;
    } catch (err) {
        console.error('Mermaid render failed:', err);
        container.innerHTML = `<pre>${mermaidCode}</pre>`; // Fallback
    }
}

// In your selector event listener:
selector.addEventListener('change', async (e) => {
    const selected = enhancedRagData.find(r => r.type === e.target.value);
    if (selected) {
        // ... other updates ...
        
        // Render diagrams dynamically
        await renderDynamicDiagram(selected.indexingMermaid, 'indexingMermaid');
        await renderDynamicDiagram(selected.inferenceMermaid, 'inferenceMermaid');
    }
});