Made changes to the backend

MAIN_PYTHON_README.md

@@ -0,0 +1,194 @@
+# main.py - CBT RAG Ablation Study Pipeline
+
+## Overview
+
+`main.py` is the main entry point for the Cognitive Behavioral Therapy (CBT) RAG ablation study. It orchestrates a comprehensive comparative analysis of 6 different chunking techniques, evaluating each with multiple LLM models.
+
+## Pipeline Flow
+
+The system executes the following steps:
+
+### Step 1: Data Ingestion with 6 Chunking Techniques
+
+```python
+all_chunks, final_chunks, proc, index = ingest_data()
+```
+
+- Loads the CBT book from `EntireBookCleaned.txt`
+- Processes the book with **6 different chunking techniques**:
+  1. **fixed** - Fixed-size chunking (1000 chars, 100 overlap)
+  2. **sentence** - Sentence-level chunking (NLTK)
+  3. **paragraph** - Paragraph-level chunking (splits on `\n\n`)
+  4. **semantic** - Semantic chunking (embedding similarity)
+  5. **recursive** - Recursive chunking (hierarchical separators)
+  6. **page** - Page-level chunking (splits on `--- Page` markers)
+- Each chunk is tagged with `chunking_technique` metadata
+- All chunks are uploaded to a **single Pinecone index** for comparison
+- **Returns:** All chunks, configured technique chunks, processor, and index for reuse
+
+### Step 2: Initialize Components
+
+```python
+rag_engine = RAGGenerator()
+models = {name: MODEL_MAP[name](token=hf_token) for name in cfg.model_list}
+evaluator = RAGEvaluator(
+    judge_model=cfg.gen['judge_model'],
+    embedding_model=proc.encoder,
+    api_key=groq_key
+)
+```
+
+- Initializes the RAG answer generator
+- Loads all 5 LLM models for tournament
+- Sets up the evaluator with judge model
+
+### Step 3: Run RAG for Each Technique (Loop)
+
+```python
+for technique in CHUNKING_TECHNIQUES:
+    results = run_rag_for_technique(
+        technique_name=technique['name'],
+        query=query,
+        index=index,
+        encoder=proc.encoder,
+        models=models,
+        evaluator=evaluator,
+        rag_engine=rag_engine
+    )
+```
+
+For each technique:
+
+- **Filters** chunks by `chunking_technique` metadata
+- **Retrieves** top 5 chunks using Pinecone query with filter
+- **Runs** model tournament (all 5 models generate answers)
+- **Evaluates** faithfulness and relevancy for each answer
+- **Stores** results for comparison
+
+### Step 4: Generate Findings Document
+
+```python
+findings_file = generate_findings_document(all_results, query)
+```
+
+- Creates comprehensive markdown report: `rag_ablation_findings.md`
+- Includes:
+  - Results table for each technique
+  - Best model per technique
+  - Sample answers
+  - Comparative analysis and ranking
+  - Recommendations
+
+### Step 5: Summary Output
+
+- Displays quick summary table
+- Shows average scores per technique
+- Identifies best performing technique and model
+- Points to detailed findings document
+
+## Configuration
+
+The system uses `config.yaml` for all configuration:
+
+```yaml
+processing:
+  embedding_model: "jinaai/jina-embeddings-v2-small-en"
+  technique: "recursive" # Default technique for retrieval
+  chunk_size: 1000
+  chunk_overlap: 100
+
+retrieval:
+  mode: "hybrid"
+  rerank_strategy: "cross-encoder"
+  use_mmr: true
+  top_k: 10
+  final_k: 5
+
+generation:
+  temperature: 0.1
+  max_new_tokens: 512
+  judge_model: "llama-3.1-8b-instant"
+```
+
+## Key Components
+
+### Data Loader (`data_loader.py`)
+
+- Loads and parses the CBT book from `EntireBookCleaned.txt`
+- Splits content by page markers (`--- Page X ---`)
+- Returns a DataFrame with columns: `id`, `title`, `url`, `full_text`
+
+### Chunk Processor (`retriever/processor.py`)
+
+- Implements 7 chunking strategies (fixed, recursive, character, paragraph, sentence, semantic, page)
+- Generates embeddings using SentenceTransformers
+- Returns chunks with metadata and vector embeddings
+
+### Vector Database (`vector_db.py`)
+
+- Manages Pinecone index creation and updates
+- Handles batch upsert operations
+- Provides index statistics and chunk loading
+
+### Hybrid Retriever (`retriever/retriever.py`)
+
+- Combines semantic search (vector embeddings) with keyword search (BM25)
+- Supports reranking strategies (cross-encoder, reciprocal rank fusion)
+- Implements Maximum Marginal Relevance (MMR) for diversity
+
+### RAG Generator (`retriever/generator.py`)
+
+- Generates answers using the configured LLM
+- Formats context chunks into prompts
+- Handles model-specific tokenization
+
+### Evaluator (`retriever/evaluator.py`)
+
+- Evaluates faithfulness (answer grounded in context)
+- Evaluates relevancy (answer addresses query)
+- Uses a judge model for automated evaluation
+
+## Usage
+
+### Basic Usage
+
+```bash
+python main.py
+```
+
+### With Environment Variables
+
+```bash
+export HF_TOKEN="your_huggingface_token"
+export PINECONE_API_KEY="your_pinecone_key"
+export OPENROUTER_API_KEY="your_openrouter_key"
+python main.py
+```
+
+## Output
+
+The system produces:
+
+1. **Ingestion Summary** - Chunks created per technique
+2. **Book Statistics** - Pages, characters, average length
+3. **Retrieval Results** - Number of context chunks retrieved
+4. **Model Answers** - Generated answers from each model
+5. **Evaluation Scores** - Faithfulness and relevancy scores
+6. **Tournament Results** - Final comparison table
+7. **Best Model** - Model with highest combined score
+
+## Ablation Study Support
+
+By running `ingest_data()` first, all 6 chunking techniques are processed and stored in a single Pinecone index. This enables:
+
+- **Comparative analysis** of different chunking strategies
+- **Filtering by technique** using the `chunking_technique` metadata field
+- **Performance evaluation** across different chunking methods
+
+## Notes
+
+- The system uses **Jina embeddings** (512 dimensions) for vector representation
+- **Pinecone** is used as the vector database (serverless, AWS us-east-1)
+- **OpenRouter** is used for the judge model inference
+- The default retrieval technique is **recursive** (configurable in `config.yaml`)
+- All 6 techniques are processed during ingestion for ablation study

config.yaml

@@ -32,10 +32,10 @@ retrieval:
   final_k: 5
 
 generation:
-  temperature: 0.1
+  temperature: 0.
   max_new_tokens: 512
-  # The model used to Judge the others
-  judge_model: "llama-3.1-8b-instant"
+  # The model used to Judge the others (OpenRouter)
+  judge_model: "stepfun/step-3.5-flash:free"
 
 # List of contestants in the tournament
 models:

frontend/app/globals.css

@@ -139,3 +139,142 @@
 .animate-gradient {
   animation: gradient 8s linear infinite;
 }
+
+@keyframes streamCursorBlink {
+  0%,
+  45% {
+    opacity: 1;
+  }
+  55%,
+  100% {
+    opacity: 0;
+  }
+}
+
+@keyframes streamTextReveal {
+  from {
+    opacity: 0.65;
+  }
+  to {
+    opacity: 1;
+  }
+}
+
+.streaming-text-reveal {
+  animation: streamTextReveal 180ms ease-out;
+}
+
+.stream-cursor {
+  display: inline-block;
+  width: 0.55ch;
+  margin-left: 0.1ch;
+  border-bottom: 0.12em solid currentColor;
+  animation: streamCursorBlink 1s steps(1, end) infinite;
+  vertical-align: baseline;
+}
+
+.assistant-streaming-bubble {
+  background-image: linear-gradient(180deg, rgba(16, 185, 129, 0.06), rgba(16, 185, 129, 0));
+}
+
+.markdown-body {
+  line-height: 1.6;
+}
+
+.markdown-body > * + * {
+  margin-top: 0.65rem;
+}
+
+.markdown-body h1,
+.markdown-body h2,
+.markdown-body h3,
+.markdown-body h4 {
+  font-weight: 700;
+  line-height: 1.35;
+}
+
+.markdown-body h1 {
+  font-size: 1.1rem;
+}
+
+.markdown-body h2 {
+  font-size: 1.02rem;
+}
+
+.markdown-body h3,
+.markdown-body h4 {
+  font-size: 0.95rem;
+}
+
+.markdown-body p {
+  margin: 0;
+}
+
+.markdown-body ul,
+.markdown-body ol {
+  margin-left: 1.1rem;
+}
+
+.markdown-body li + li {
+  margin-top: 0.2rem;
+}
+
+.markdown-body a {
+  text-decoration: underline;
+  text-underline-offset: 2px;
+}
+
+.markdown-body code {
+  border-radius: 0.35rem;
+  background: rgba(148, 163, 184, 0.2);
+  padding: 0.05rem 0.35rem;
+  font-family: ui-monospace, SFMono-Regular, Menlo, Monaco, Consolas, "Liberation Mono", "Courier New", monospace;
+  font-size: 0.82em;
+}
+
+.markdown-body pre {
+  overflow-x: auto;
+  border-radius: 0.75rem;
+  border: 1px solid rgba(148, 163, 184, 0.3);
+  background: rgba(2, 6, 23, 0.92);
+  color: #e2e8f0;
+  padding: 0.75rem;
+}
+
+.markdown-body pre code {
+  background: transparent;
+  padding: 0;
+  color: inherit;
+  font-size: 0.78rem;
+}
+
+.markdown-body table {
+  width: 100%;
+  border-collapse: collapse;
+  font-size: 0.86rem;
+}
+
+.markdown-body th,
+.markdown-body td {
+  border: 1px solid rgba(148, 163, 184, 0.35);
+  padding: 0.4rem 0.5rem;
+  text-align: left;
+}
+
+.markdown-body th {
+  background: rgba(148, 163, 184, 0.15);
+  font-weight: 600;
+}
+
+.markdown-body blockquote {
+  border-left: 3px solid rgba(148, 163, 184, 0.45);
+  margin: 0;
+  padding-left: 0.7rem;
+  color: inherit;
+  opacity: 0.9;
+}
+
+.markdown-body hr {
+  border: 0;
+  border-top: 1px solid rgba(148, 163, 184, 0.35);
+}

frontend/components/AIAssistantUI.jsx

@@ -84,6 +84,14 @@ export default function AIAssistantUI() {
 
   const [isThinking, setIsThinking] = useState(false)
   const [thinkingConvId, setThinkingConvId] = useState(null)
+  const activeRequestRef = useRef(null)
+
+  useEffect(() => {
+    return () => {
+      activeRequestRef.current?.abort()
+      activeRequestRef.current = null
+    }
+  }, [])
 
   useEffect(() => {
     const onKey = (e) => {
@@ -193,8 +201,13 @@ export default function AIAssistantUI() {
 
   async function sendMessage(convId, content) {
     if (!content.trim()) return
+    const existingConversation = conversations.find((c) => c.id === convId)
+    const hasUserMessages = (existingConversation?.messages || []).some((m) => m.role === "user")
+    const shouldAutoTitle = existingConversation?.title === "New Chat" && !hasUserMessages
+
     const now = new Date().toISOString()
     const userMsg = { id: Math.random().toString(36).slice(2), role: "user", content, createdAt: now }
+    const assistantMsgId = Math.random().toString(36).slice(2)
 
     setConversations((prev) =>
       prev.map((c) => {
@@ -213,7 +226,124 @@ export default function AIAssistantUI() {
     setIsThinking(true)
     setThinkingConvId(convId)
 
+    if (shouldAutoTitle) {
+      const primaryUrl = "/api/proxy"
+      const fallbackUrl = process.env.NEXT_PUBLIC_API_URL || "http://127.0.0.1:8000"
+      const titlePayload = {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ query: content }),
+      }
+
+      ;(async () => {
+        try {
+          let res
+          try {
+            res = await fetch(`${primaryUrl}/predict/title`, titlePayload)
+          } catch {}
+
+          if (!res || !res.ok) {
+            res = await fetch(`${fallbackUrl}/predict/title`, titlePayload)
+          }
+
+          if (!res.ok) return
+          const data = await res.json().catch(() => null)
+          const nextTitle = (data?.title || "").trim()
+          if (!nextTitle) return
+
+          setConversations((prev) =>
+            prev.map((c) => {
+              if (c.id !== convId) return c
+              if (c.title !== "New Chat") return c
+              return {
+                ...c,
+                title: nextTitle.slice(0, 80),
+                updatedAt: new Date().toISOString(),
+              }
+            }),
+          )
+        } catch {
+          // Keep default title if title endpoint is unavailable.
+        }
+      })()
+    }
+
     const currentConvId = convId
+    const controller = new AbortController()
+    activeRequestRef.current = controller
+
+    const upsertAssistantMessage = (updater, fallbackContent = "") => {
+      setConversations((prev) =>
+        prev.map((c) => {
+          if (c.id !== currentConvId) return c
+          const existingMessages = c.messages || []
+          const idx = existingMessages.findIndex((m) => m.id === assistantMsgId)
+          const baseMessage =
+            idx >= 0
+              ? existingMessages[idx]
+              : {
+                  id: assistantMsgId,
+                  role: "assistant",
+                  content: fallbackContent,
+                  createdAt: new Date().toISOString(),
+                  isStreaming: true,
+                }
+
+          const nextMessage = updater(baseMessage)
+          const nextMessages = [...existingMessages]
+          if (idx >= 0) {
+            nextMessages[idx] = nextMessage
+          } else {
+            nextMessages.push(nextMessage)
+          }
+
+          return {
+            ...c,
+            messages: nextMessages,
+            updatedAt: new Date().toISOString(),
+            messageCount: nextMessages.length,
+            preview: nextMessages[nextMessages.length - 1]?.content?.slice(0, 80) || c.preview,
+          }
+        }),
+      )
+    }
+
+    const appendChunk = (chunk) => {
+      if (!chunk) return
+      upsertAssistantMessage(
+        (m) => ({
+          ...m,
+          content: (m.content || "") + chunk,
+          isStreaming: true,
+        }),
+        "",
+      )
+    }
+
+    const finalizeAssistant = (finalText) => {
+      upsertAssistantMessage(
+        (m) => {
+          const fallbackContent = m.content || "Sorry, I encountered an error."
+          return {
+            ...m,
+            content: finalText != null ? finalText : fallbackContent,
+            isStreaming: false,
+          }
+        },
+        finalText || "Sorry, I encountered an error.",
+      )
+    }
+
+    const setAssistantError = (message) => {
+      upsertAssistantMessage(
+        (m) => ({
+          ...m,
+          content: message,
+          isStreaming: false,
+        }),
+        message,
+      )
+    }
 
     // Prefer same-origin proxy to avoid browser CORS/network issues in development.
     const primaryUrl = "/api/proxy"
@@ -226,18 +356,19 @@ export default function AIAssistantUI() {
         query: content,
         model: selectedModel,
       }),
+      signal: controller.signal,
     }
 
     try {
       let res
 
       try {
-        res = await fetch(`${primaryUrl}/predict`, fetchOptions)
+        res = await fetch(`${primaryUrl}/predict/stream`, fetchOptions)
       } catch {}
 
       if (!res || !res.ok) {
         // Retry direct backend URL if proxy is not reachable.
-        res = await fetch(`${fallbackUrl}/predict`, fetchOptions)
+        res = await fetch(`${fallbackUrl}/predict/stream`, fetchOptions)
       }
 
       if (!res.ok) {
@@ -245,49 +376,83 @@ export default function AIAssistantUI() {
         throw new Error(`Prediction failed (${res.status}) ${details}`.trim())
       }
 
-      const data = await res.json()
+      if (!res.body) {
+        throw new Error("Streaming is not available in this browser response")
+      }
 
-      setConversations((prev) =>
-        prev.map((c) => {
-          if (c.id !== currentConvId) return c
-          const asstMsg = {
-            id: Math.random().toString(36).slice(2),
-            role: "assistant",
-            content: data.answer || "Sorry, I encountered an error.",
-            createdAt: new Date().toISOString(),
+      const reader = res.body.getReader()
+      const decoder = new TextDecoder()
+      let buffer = ""
+      let firstTokenReceived = false
+      let finalAnswer = null
+
+      while (true) {
+        const { value, done } = await reader.read()
+        if (done) break
+
+        buffer += decoder.decode(value, { stream: true })
+        const lines = buffer.split("\n")
+        buffer = lines.pop() || ""
+
+        for (const line of lines) {
+          const trimmed = line.trim()
+          if (!trimmed) continue
+
+          let evt
+          try {
+            evt = JSON.parse(trimmed)
+          } catch {
+            continue
           }
-          const msgs = [...(c.messages || []), asstMsg]
-          return {
-            ...c,
-            messages: msgs,
-            updatedAt: new Date().toISOString(),
-            messageCount: msgs.length,
-            preview: (asstMsg.content || "").slice(0, 80),
+
+          if (evt.type === "token") {
+            if (!firstTokenReceived) {
+              firstTokenReceived = true
+              setIsThinking(false)
+            }
+            appendChunk(evt.token || "")
           }
-        }),
-      )
-    } catch (err) {
-      console.error("predict request failed:", err)
-      setConversations((prev) =>
-        prev.map((c) => {
-          if (c.id !== currentConvId) return c
-          const errorMsg = {
-            id: Math.random().toString(36).slice(2),
-            role: "assistant",
-            content: "Sorry, I could not reach the backend. Start FastAPI and verify frontend .env.local URLs, then restart Next.js dev server.",
-            createdAt: new Date().toISOString(),
+
+          if (evt.type === "done") {
+            finalAnswer = typeof evt.answer === "string" ? evt.answer : null
           }
-          const msgs = [...(c.messages || []), errorMsg]
-          return {
-            ...c,
-            messages: msgs,
-            updatedAt: new Date().toISOString(),
-            messageCount: msgs.length,
-            preview: errorMsg.content.slice(0, 80),
+
+          if (evt.type === "error") {
+            throw new Error(evt.message || "Streaming failed")
           }
-        }),
-      )
+        }
+      }
+
+      const remainder = buffer.trim()
+      if (remainder) {
+        try {
+          const evt = JSON.parse(remainder)
+          if (evt.type === "done") {
+            finalAnswer = typeof evt.answer === "string" ? evt.answer : null
+          }
+          if (evt.type === "token") {
+            appendChunk(evt.token || "")
+          }
+          if (evt.type === "error") {
+            throw new Error(evt.message || "Streaming failed")
+          }
+        } catch {
+          // Ignore malformed tail chunk.
+        }
+      }
+
+      finalizeAssistant(finalAnswer)
+    } catch (err) {
+      console.error("predict request failed:", err)
+      if (err?.name === "AbortError") {
+        setAssistantError("Generation paused.")
+      } else {
+        setAssistantError("Sorry, I could not reach the backend. Start FastAPI and verify frontend .env.local URLs, then restart Next.js dev server.")
+      }
     } finally {
+      if (activeRequestRef.current === controller) {
+        activeRequestRef.current = null
+      }
       setIsThinking(false)
       setThinkingConvId(null)
     }
@@ -318,6 +483,8 @@ export default function AIAssistantUI() {
   }
 
   function pauseThinking() {
+    activeRequestRef.current?.abort()
+    activeRequestRef.current = null
     setIsThinking(false)
     setThinkingConvId(null)
   }

frontend/components/ChatPane.jsx

@@ -3,6 +3,7 @@
 import { useState, forwardRef, useImperativeHandle, useRef } from "react"
 import { RefreshCw, Check, X, Square } from "lucide-react"
 import Message from "./Message"
+import MarkdownMessage from "./MarkdownMessage"
 import Composer from "./Composer"
 import { cls, timeAgo } from "./utils"
 
@@ -171,8 +172,14 @@ const ChatPane = forwardRef(function ChatPane(
                     </div>
                   </div>
                 ) : (
-                  <Message role={m.role}>
-                    <div className="whitespace-pre-wrap">{m.content}</div>
+                  <Message role={m.role} streaming={Boolean(m.isStreaming)}>
+                    {m.role === "assistant" ? (
+                      <div className={cls(m.isStreaming && "streaming-text-reveal")}>
+                        <MarkdownMessage content={m.content} isStreaming={Boolean(m.isStreaming)} />
+                      </div>
+                    ) : (
+                      <div className="whitespace-pre-wrap">{m.content}</div>
+                    )}
                   </Message>
                 )}
               </div>

frontend/components/MarkdownMessage.jsx

@@ -0,0 +1,27 @@
+"use client"
+
+import ReactMarkdown from "react-markdown"
+import remarkGfm from "remark-gfm"
+import rehypeSanitize from "rehype-sanitize"
+
+function withTemporaryFenceClosure(markdown) {
+  const text = markdown || ""
+  const fenceMatches = text.match(/```/g)
+  const fenceCount = fenceMatches ? fenceMatches.length : 0
+  if (fenceCount % 2 === 1) {
+    return `${text}\n\n\`\`\`\n`
+  }
+  return text
+}
+
+export default function MarkdownMessage({ content, isStreaming = false }) {
+  const source = isStreaming ? withTemporaryFenceClosure(content) : content || ""
+
+  return (
+    <div className="markdown-body">
+      <ReactMarkdown remarkPlugins={[remarkGfm]} rehypePlugins={[rehypeSanitize]}>
+        {source}
+      </ReactMarkdown>
+    </div>
+  )
+}

frontend/components/Message.jsx

@@ -1,6 +1,6 @@
 import { cls } from "./utils"
 
-export default function Message({ role, children }) {
+export default function Message({ role, children, streaming = false }) {
   const isUser = role === "user"
   return (
     <div className={cls("flex gap-3", isUser ? "justify-end" : "justify-start")}>
@@ -17,6 +17,7 @@ export default function Message({ role, children }) {
               isUser
                 ? "bg-zinc-900 text-white dark:bg-white dark:text-zinc-900"
                 : "bg-white text-zinc-900 dark:bg-zinc-900 dark:text-zinc-100 border border-zinc-200 dark:border-zinc-800",
+              !isUser && streaming && "assistant-streaming-bubble",
             )}
           >
             {children}

frontend/package-lock.json

@@ -21,7 +21,10 @@
         "react-dom": "^19.2.1",
         "react-dropzone": "^14.3.8",
         "react-icons": "^5.5.0",
+        "react-markdown": "^10.1.0",
         "react-use-measure": "^2.1.7",
+        "rehype-sanitize": "^6.0.0",
+        "remark-gfm": "^4.0.1",
         "tailwind-merge": "^3.3.1"
       },
       "devDependencies": {
@@ -3643,13 +3646,39 @@
         "tslib": "^2.4.0"
       }
     },
+    "node_modules/@types/debug": {
+      "version": "4.1.13",
+      "resolved": "https://registry.npmjs.org/@types/debug/-/debug-4.1.13.tgz",
+      "integrity": "sha512-KSVgmQmzMwPlmtljOomayoR89W4FynCAi3E8PPs7vmDVPe84hT+vGPKkJfThkmXs0x0jAaa9U8uW8bbfyS2fWw==",
+      "license": "MIT",
+      "dependencies": {
+        "@types/ms": "*"
+      }
+    },
     "node_modules/@types/estree": {
       "version": "1.0.8",
       "resolved": "https://registry.npmjs.org/@types/estree/-/estree-1.0.8.tgz",
       "integrity": "sha512-dWHzHa2WqEXI/O1E9OjrocMTKJl2mSrEolh1Iomrv6U+JuNwaHXsXx9bLu5gG7BUWFIN0skIQJQ/L1rIex4X6w==",
-      "dev": true,
       "license": "MIT"
     },
+    "node_modules/@types/estree-jsx": {
+      "version": "1.0.5",
+      "resolved": "https://registry.npmjs.org/@types/estree-jsx/-/estree-jsx-1.0.5.tgz",
+      "integrity": "sha512-52CcUVNFyfb1A2ALocQw/Dd1BQFNmSdkuC3BkZ6iqhdMfQz7JWOFRuJFloOzjk+6WijU56m9oKXFAXc7o3Towg==",
+      "license": "MIT",
+      "dependencies": {
+        "@types/estree": "*"
+      }
+    },
+    "node_modules/@types/hast": {
+      "version": "3.0.4",
+      "resolved": "https://registry.npmjs.org/@types/hast/-/hast-3.0.4.tgz",
+      "integrity": "sha512-WPs+bbQw5aCj+x6laNGWLH3wviHtoCv/P3+otBhbOhJgG8qtpdAMlTCxLtsTWA7LH1Oh/bFCHsBn0TPS5m30EQ==",
+      "license": "MIT",
+      "dependencies": {
+        "@types/unist": "*"
+      }
+    },
     "node_modules/@types/json-schema": {
       "version": "7.0.15",
       "resolved": "https://registry.npmjs.org/@types/json-schema/-/json-schema-7.0.15.tgz",
@@ -3664,6 +3693,21 @@
       "dev": true,
       "license": "MIT"
     },
+    "node_modules/@types/mdast": {
+      "version": "4.0.4",
+      "resolved": "https://registry.npmjs.org/@types/mdast/-/mdast-4.0.4.tgz",
+      "integrity": "sha512-kGaNbPh1k7AFzgpud/gMdvIm5xuECykRR+JnWKQno9TAXVa6WIVCGTPvYGekIDL4uwCZQSYbUxNBSb1aUo79oA==",
+      "license": "MIT",
+      "dependencies": {
+        "@types/unist": "*"
+      }
+    },
+    "node_modules/@types/ms": {
+      "version": "2.1.0",
+      "resolved": "https://registry.npmjs.org/@types/ms/-/ms-2.1.0.tgz",
+      "integrity": "sha512-GsCCIZDE/p3i96vtEqx+7dBUGXrc7zeSK3wwPHIaRThS+9OhWIXRqzs4d6k1SVU8g91DrNRWxWUGhp5KXQb2VA==",
+      "license": "MIT"
+    },
     "node_modules/@types/node": {
       "version": "20.19.24",
       "resolved": "https://registry.npmjs.org/@types/node/-/node-20.19.24.tgz",
@@ -3678,7 +3722,6 @@
       "version": "19.2.2",
       "resolved": "https://registry.npmjs.org/@types/react/-/react-19.2.2.tgz",
       "integrity": "sha512-6mDvHUFSjyT2B2yeNx2nUgMxh9LtOWvkhIU3uePn2I2oyNymUAX1NIsdgviM4CH+JSrp2D2hsMvJOkxY+0wNRA==",
-      "devOptional": true,
       "license": "MIT",
       "dependencies": {
         "csstype": "^3.0.2"
@@ -3694,6 +3737,12 @@
         "@types/react": "^19.2.0"
       }
     },
+    "node_modules/@types/unist": {
+      "version": "3.0.3",
+      "resolved": "https://registry.npmjs.org/@types/unist/-/unist-3.0.3.tgz",
+      "integrity": "sha512-ko/gIFJRv177XgZsZcBwnqJN5x/Gien8qNOn0D5bQU/zAzVf9Zt3BlcUiLqhV9y4ARk0GbT3tnUiPNgnTXzc/Q==",
+      "license": "MIT"
+    },
     "node_modules/@typescript-eslint/eslint-plugin": {
       "version": "8.46.3",
       "resolved": "https://registry.npmjs.org/@typescript-eslint/eslint-plugin/-/eslint-plugin-8.46.3.tgz",
@@ -3995,6 +4044,12 @@
         "url": "https://opencollective.com/typescript-eslint"
       }
     },
+    "node_modules/@ungap/structured-clone": {
+      "version": "1.3.0",
+      "resolved": "https://registry.npmjs.org/@ungap/structured-clone/-/structured-clone-1.3.0.tgz",
+      "integrity": "sha512-WmoN8qaIAo7WTYWbAZuG8PYEhn5fkz7dZrqTBZ7dtt//lL2Gwms1IcnQ5yHqjDfX8Ft5j4YzDM23f87zBfDe9g==",
+      "license": "ISC"
+    },
     "node_modules/@unrs/resolver-binding-android-arm-eabi": {
       "version": "1.11.1",
       "resolved": "https://registry.npmjs.org/@unrs/resolver-binding-android-arm-eabi/-/resolver-binding-android-arm-eabi-1.11.1.tgz",
@@ -4609,6 +4664,16 @@
         "@babel/core": "^7.4.0 || ^8.0.0-0 <8.0.0"
       }
     },
+    "node_modules/bail": {
+      "version": "2.0.2",
+      "resolved": "https://registry.npmjs.org/bail/-/bail-2.0.2.tgz",
+      "integrity": "sha512-0xO6mYd7JB2YesxDKplafRpsiOzPt9V02ddPCLbY1xYGPOX24NTyN50qnUxgCPcSoYMhKpAuBTjQoRZCAkUDRw==",
+      "license": "MIT",
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/wooorm"
+      }
+    },
     "node_modules/balanced-match": {
       "version": "1.0.2",
       "resolved": "https://registry.npmjs.org/balanced-match/-/balanced-match-1.0.2.tgz",
@@ -4779,6 +4844,16 @@
       ],
       "license": "CC-BY-4.0"
     },
+    "node_modules/ccount": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/ccount/-/ccount-2.0.1.tgz",
+      "integrity": "sha512-eyrF0jiFpY+3drT6383f1qhkbGsLSifNAjA61IUjZjmLCWjItY6LB9ft9YhoDgwfmclB2zhu51Lc7+95b8NRAg==",
+      "license": "MIT",
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/wooorm"
+      }
+    },
     "node_modules/chalk": {
       "version": "4.1.2",
       "resolved": "https://registry.npmjs.org/chalk/-/chalk-4.1.2.tgz",
@@ -4796,6 +4871,46 @@
         "url": "https://github.com/chalk/chalk?sponsor=1"
       }
     },
+    "node_modules/character-entities": {
+      "version": "2.0.2",
+      "resolved": "https://registry.npmjs.org/character-entities/-/character-entities-2.0.2.tgz",
+      "integrity": "sha512-shx7oQ0Awen/BRIdkjkvz54PnEEI/EjwXDSIZp86/KKdbafHh1Df/RYGBhn4hbe2+uKC9FnT5UCEdyPz3ai9hQ==",
+      "license": "MIT",
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/wooorm"
+      }
+    },
+    "node_modules/character-entities-html4": {
+      "version": "2.1.0",
+      "resolved": "https://registry.npmjs.org/character-entities-html4/-/character-entities-html4-2.1.0.tgz",
+      "integrity": "sha512-1v7fgQRj6hnSwFpq1Eu0ynr/CDEw0rXo2B61qXrLNdHZmPKgb7fqS1a2JwF0rISo9q77jDI8VMEHoApn8qDoZA==",
+      "license": "MIT",
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/wooorm"
+      }
+    },
+    "node_modules/character-entities-legacy": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/character-entities-legacy/-/character-entities-legacy-3.0.0.tgz",
+      "integrity": "sha512-RpPp0asT/6ufRm//AJVwpViZbGM/MkjQFxJccQRHmISF/22NBtsHqAWmL+/pmkPWoIUJdWyeVleTl1wydHATVQ==",
+      "license": "MIT",
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/wooorm"
+      }
+    },
+    "node_modules/character-reference-invalid": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/character-reference-invalid/-/character-reference-invalid-2.0.1.tgz",
+      "integrity": "sha512-iBZ4F4wRbyORVsu0jPV7gXkOsGYjGHPmAyv+HiHG8gi5PtC9KI2j1+v8/tlibRvjoWX027ypmG/n0HtO5t7unw==",
+      "license": "MIT",
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/wooorm"
+      }
+    },
     "node_modules/class-variance-authority": {
       "version": "0.7.1",
       "resolved": "https://registry.npmjs.org/class-variance-authority/-/class-variance-authority-0.7.1.tgz",
@@ -4843,6 +4958,16 @@
       "dev": true,
       "license": "MIT"
     },
+    "node_modules/comma-separated-tokens": {
+      "version": "2.0.3",
+      "resolved": "https://registry.npmjs.org/comma-separated-tokens/-/comma-separated-tokens-2.0.3.tgz",
+      "integrity": "sha512-Fu4hJdvzeylCfQPp9SGWidpzrMs7tTrlu6Vb8XGaRGck8QSNZJJp538Wrb60Lax4fPwR64ViY468OIUTbRlGZg==",
+      "license": "MIT",
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/wooorm"
+      }
+    },
     "node_modules/commander": {
       "version": "7.2.0",
       "resolved": "https://registry.npmjs.org/commander/-/commander-7.2.0.tgz",
@@ -4997,7 +5122,6 @@
       "version": "3.1.3",
       "resolved": "https://registry.npmjs.org/csstype/-/csstype-3.1.3.tgz",
       "integrity": "sha512-M1uQkMl8rQK/szD0LNhtqxIPLpimGm8sOBwU7lLnCpSbTyY3yeU1Vc7l4KT5zT4s/yOxHH5O7tIuuLOCnLADRw==",
-      "devOptional": true,
       "license": "MIT"
     },
     "node_modules/damerau-levenshtein": {
@@ -5078,6 +5202,19 @@
         }
       }
     },
+    "node_modules/decode-named-character-reference": {
+      "version": "1.3.0",
+      "resolved": "https://registry.npmjs.org/decode-named-character-reference/-/decode-named-character-reference-1.3.0.tgz",
+      "integrity": "sha512-GtpQYB283KrPp6nRw50q3U9/VfOutZOe103qlN7BPP6Ad27xYnOIWv4lPzo8HCAL+mMZofJ9KEy30fq6MfaK6Q==",
+      "license": "MIT",
+      "dependencies": {
+        "character-entities": "^2.0.0"
+      },
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/wooorm"
+      }
+    },
     "node_modules/deep-is": {
       "version": "0.1.4",
       "resolved": "https://registry.npmjs.org/deep-is/-/deep-is-0.1.4.tgz",
@@ -5130,6 +5267,15 @@
         "url": "https://github.com/sponsors/ljharb"
       }
     },
+    "node_modules/dequal": {
+      "version": "2.0.3",
+      "resolved": "https://registry.npmjs.org/dequal/-/dequal-2.0.3.tgz",
+      "integrity": "sha512-0je+qPKHEMohvfRTCEo3CrPG6cAzAYgmzKyxRiYSSDkS6eGJdyVJm7WaYA5ECaAD9wLB2T4EEeymA5aFVcYXCA==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=6"
+      }
+    },
     "node_modules/detect-libc": {
       "version": "2.1.2",
       "resolved": "https://registry.npmjs.org/detect-libc/-/detect-libc-2.1.2.tgz",
@@ -5146,6 +5292,19 @@
       "integrity": "sha512-ypdmJU/TbBby2Dxibuv7ZLW3Bs1QEmM7nHjEANfohJLvE0XVujisn1qPJcZxg+qDucsr+bP6fLD1rPS3AhJ7EQ==",
       "license": "MIT"
     },
+    "node_modules/devlop": {
+      "version": "1.1.0",
+      "resolved": "https://registry.npmjs.org/devlop/-/devlop-1.1.0.tgz",
+      "integrity": "sha512-RWmIqhcFf1lRYBvNmr7qTNuyCt/7/ns2jbpp1+PalgE/rDQcBT0fioSMUpJ93irlUhC5hrg4cYqe6U+0ImW0rA==",
+      "license": "MIT",
+      "dependencies": {
+        "dequal": "^2.0.0"
+      },
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/wooorm"
+      }
+    },
     "node_modules/doctrine": {
       "version": "2.1.0",
       "resolved": "https://registry.npmjs.org/doctrine/-/doctrine-2.1.0.tgz",
@@ -5900,6 +6059,16 @@
         "node": ">=4.0"
       }
     },
+    "node_modules/estree-util-is-identifier-name": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/estree-util-is-identifier-name/-/estree-util-is-identifier-name-3.0.0.tgz",
+      "integrity": "sha512-hFtqIDZTIUZ9BXLb8y4pYGyk6+wekIivNVTcmvk8NoOh+VeRn5y6cEHzbURrWbfp1fIqdVipilzj+lfaadNZmg==",
+      "license": "MIT",
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
     "node_modules/esutils": {
       "version": "2.0.3",
       "resolved": "https://registry.npmjs.org/esutils/-/esutils-2.0.3.tgz",
@@ -5909,6 +6078,12 @@
         "node": ">=0.10.0"
       }
     },
+    "node_modules/extend": {
+      "version": "3.0.2",
+      "resolved": "https://registry.npmjs.org/extend/-/extend-3.0.2.tgz",
+      "integrity": "sha512-fjquC59cD7CyW6urNXK0FBufkZcoiGG80wTuPujX590cB5Ttln20E2UB4S/WARVqhXffZl2LNgS+gQdPIIim/g==",
+      "license": "MIT"
+    },
     "node_modules/fast-deep-equal": {
       "version": "3.1.3",
       "resolved": "https://registry.npmjs.org/fast-deep-equal/-/fast-deep-equal-3.1.3.tgz",
@@ -6390,6 +6565,61 @@
         "node": ">= 0.4"
       }
     },
+    "node_modules/hast-util-sanitize": {
+      "version": "5.0.2",
+      "resolved": "https://registry.npmjs.org/hast-util-sanitize/-/hast-util-sanitize-5.0.2.tgz",
+      "integrity": "sha512-3yTWghByc50aGS7JlGhk61SPenfE/p1oaFeNwkOOyrscaOkMGrcW9+Cy/QAIOBpZxP1yqDIzFMR0+Np0i0+usg==",
+      "license": "MIT",
+      "dependencies": {
+        "@types/hast": "^3.0.0",
+        "@ungap/structured-clone": "^1.0.0",
+        "unist-util-position": "^5.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/hast-util-to-jsx-runtime": {
+      "version": "2.3.6",
+      "resolved": "https://registry.npmjs.org/hast-util-to-jsx-runtime/-/hast-util-to-jsx-runtime-2.3.6.tgz",
+      "integrity": "sha512-zl6s8LwNyo1P9uw+XJGvZtdFF1GdAkOg8ujOw+4Pyb76874fLps4ueHXDhXWdk6YHQ6OgUtinliG7RsYvCbbBg==",
+      "license": "MIT",
+      "dependencies": {
+        "@types/estree": "^1.0.0",
+        "@types/hast": "^3.0.0",
+        "@types/unist": "^3.0.0",
+        "comma-separated-tokens": "^2.0.0",
+        "devlop": "^1.0.0",
+        "estree-util-is-identifier-name": "^3.0.0",
+        "hast-util-whitespace": "^3.0.0",
+        "mdast-util-mdx-expression": "^2.0.0",
+        "mdast-util-mdx-jsx": "^3.0.0",
+        "mdast-util-mdxjs-esm": "^2.0.0",
+        "property-information": "^7.0.0",
+        "space-separated-tokens": "^2.0.0",
+        "style-to-js": "^1.0.0",
+        "unist-util-position": "^5.0.0",
+        "vfile-message": "^4.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/hast-util-whitespace": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/hast-util-whitespace/-/hast-util-whitespace-3.0.0.tgz",
+      "integrity": "sha512-88JUN06ipLwsnv+dVn+OIYOvAuvBMy/Qoi6O7mQHxdPXpjy+Cd6xRkWwux7DKO+4sYILtLBRIKgsdpS2gQc7qw==",
+      "license": "MIT",
+      "dependencies": {
+        "@types/hast": "^3.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
     "node_modules/hermes-estree": {
       "version": "0.25.1",
       "resolved": "https://registry.npmjs.org/hermes-estree/-/hermes-estree-0.25.1.tgz",
@@ -6407,6 +6637,16 @@
         "hermes-estree": "0.25.1"
       }
     },
+    "node_modules/html-url-attributes": {
+      "version": "3.0.1",
+      "resolved": "https://registry.npmjs.org/html-url-attributes/-/html-url-attributes-3.0.1.tgz",
+      "integrity": "sha512-ol6UPyBWqsrO6EJySPz2O7ZSr856WDrEzM5zMqp+FJJLGMW35cLYmmZnl0vztAZxRUoNZJFTCohfjuIJ8I4QBQ==",
+      "license": "MIT",
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
     "node_modules/ignore": {
       "version": "5.3.2",
       "resolved": "https://registry.npmjs.org/ignore/-/ignore-5.3.2.tgz",
@@ -6443,6 +6683,12 @@
         "node": ">=0.8.19"
       }
     },
+    "node_modules/inline-style-parser": {
+      "version": "0.2.7",
+      "resolved": "https://registry.npmjs.org/inline-style-parser/-/inline-style-parser-0.2.7.tgz",
+      "integrity": "sha512-Nb2ctOyNR8DqQoR0OwRG95uNWIC0C1lCgf5Naz5H6Ji72KZ8OcFZLz2P5sNgwlyoJ8Yif11oMuYs5pBQa86csA==",
+      "license": "MIT"
+    },
     "node_modules/internal-slot": {
       "version": "1.1.0",
       "resolved": "https://registry.npmjs.org/internal-slot/-/internal-slot-1.1.0.tgz",
@@ -6458,6 +6704,30 @@
         "node": ">= 0.4"
       }
     },
+    "node_modules/is-alphabetical": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/is-alphabetical/-/is-alphabetical-2.0.1.tgz",
+      "integrity": "sha512-FWyyY60MeTNyeSRpkM2Iry0G9hpr7/9kD40mD/cGQEuilcZYS4okz8SN2Q6rLCJ8gbCt6fN+rC+6tMGS99LaxQ==",
+      "license": "MIT",
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/wooorm"
+      }
+    },
+    "node_modules/is-alphanumerical": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/is-alphanumerical/-/is-alphanumerical-2.0.1.tgz",
+      "integrity": "sha512-hmbYhX/9MUMF5uh7tOXyK/n0ZvWpad5caBA17GsC6vyuCqaWliRG5K1qS9inmUhEMaOBIW7/whAnSwveW/LtZw==",
+      "license": "MIT",
+      "dependencies": {
+        "is-alphabetical": "^2.0.0",
+        "is-decimal": "^2.0.0"
+      },
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/wooorm"
+      }
+    },
     "node_modules/is-array-buffer": {
       "version": "3.0.5",
       "resolved": "https://registry.npmjs.org/is-array-buffer/-/is-array-buffer-3.0.5.tgz",
@@ -6621,6 +6891,16 @@
         "url": "https://github.com/sponsors/ljharb"
       }
     },
+    "node_modules/is-decimal": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/is-decimal/-/is-decimal-2.0.1.tgz",
+      "integrity": "sha512-AAB9hiomQs5DXWcRB1rqsxGUstbRroFOPPVAomNk/3XHR5JyEZChOyTWe2oayKnsSsr/kcGqF+z6yuH6HHpN0A==",
+      "license": "MIT",
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/wooorm"
+      }
+    },
     "node_modules/is-extglob": {
       "version": "2.1.1",
       "resolved": "https://registry.npmjs.org/is-extglob/-/is-extglob-2.1.1.tgz",
@@ -6680,6 +6960,16 @@
         "node": ">=0.10.0"
       }
     },
+    "node_modules/is-hexadecimal": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/is-hexadecimal/-/is-hexadecimal-2.0.1.tgz",
+      "integrity": "sha512-DgZQp241c8oO6cA1SbTEWiXeoxV42vlcJxgH+B3hi1AiqqKruZR3ZGF8In3fj4+/y/7rHvlOZLZtgJ/4ttYGZg==",
+      "license": "MIT",
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/wooorm"
+      }
+    },
     "node_modules/is-map": {
       "version": "2.0.3",
       "resolved": "https://registry.npmjs.org/is-map/-/is-map-2.0.3.tgz",
@@ -6733,6 +7023,18 @@
         "url": "https://github.com/sponsors/ljharb"
       }
     },
+    "node_modules/is-plain-obj": {
+      "version": "4.1.0",
+      "resolved": "https://registry.npmjs.org/is-plain-obj/-/is-plain-obj-4.1.0.tgz",
+      "integrity": "sha512-+Pgi+vMuUNkJyExiMBt5IlFoMyKnr5zhJ4Uspz58WOhBF5QoIZkFyNHIbBAtHwzVAgk5RtndVNsDRN61/mmDqg==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=12"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
     "node_modules/is-regex": {
       "version": "1.2.1",
       "resolved": "https://registry.npmjs.org/is-regex/-/is-regex-1.2.1.tgz",
@@ -7345,6 +7647,16 @@
       "dev": true,
       "license": "MIT"
     },
+    "node_modules/longest-streak": {
+      "version": "3.1.0",
+      "resolved": "https://registry.npmjs.org/longest-streak/-/longest-streak-3.1.0.tgz",
+      "integrity": "sha512-9Ri+o0JYgehTaVBBDoMqIl8GXtbWg711O3srftcHhZ0dqnETqLaoIK0x17fUw9rFSlK/0NlsKe0Ahhyl5pXE2g==",
+      "license": "MIT",
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/wooorm"
+      }
+    },
     "node_modules/loose-envify": {
       "version": "1.4.0",
       "resolved": "https://registry.npmjs.org/loose-envify/-/loose-envify-1.4.0.tgz",
@@ -7394,6 +7706,16 @@
         "@jridgewell/sourcemap-codec": "^1.5.5"
       }
     },
+    "node_modules/markdown-table": {
+      "version": "3.0.4",
+      "resolved": "https://registry.npmjs.org/markdown-table/-/markdown-table-3.0.4.tgz",
+      "integrity": "sha512-wiYz4+JrLyb/DqW2hkFJxP7Vd7JuTDm77fvbM8VfEQdmSMqcImWeeRbHwZjBjIFki/VaMK2BhFi7oUUZeM5bqw==",
+      "license": "MIT",
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/wooorm"
+      }
+    },
     "node_modules/math-intrinsics": {
       "version": "1.1.0",
       "resolved": "https://registry.npmjs.org/math-intrinsics/-/math-intrinsics-1.1.0.tgz",
@@ -7404,76 +7726,921 @@
         "node": ">= 0.4"
       }
     },
-    "node_modules/mdn-data": {
-      "version": "2.0.30",
-      "resolved": "https://registry.npmjs.org/mdn-data/-/mdn-data-2.0.30.tgz",
-      "integrity": "sha512-GaqWWShW4kv/G9IEucWScBx9G1/vsFZZJUO+tD26M8J8z3Kw5RDQjaoZe03YAClgeS/SWPOcb4nkFBTEi5DUEA==",
-      "license": "CC0-1.0"
+    "node_modules/mdast-util-find-and-replace": {
+      "version": "3.0.2",
+      "resolved": "https://registry.npmjs.org/mdast-util-find-and-replace/-/mdast-util-find-and-replace-3.0.2.tgz",
+      "integrity": "sha512-Tmd1Vg/m3Xz43afeNxDIhWRtFZgM2VLyaf4vSTYwudTyeuTneoL3qtWMA5jeLyz/O1vDJmmV4QuScFCA2tBPwg==",
+      "license": "MIT",
+      "dependencies": {
+        "@types/mdast": "^4.0.0",
+        "escape-string-regexp": "^5.0.0",
+        "unist-util-is": "^6.0.0",
+        "unist-util-visit-parents": "^6.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
     },
-    "node_modules/merge2": {
-      "version": "1.4.1",
-      "resolved": "https://registry.npmjs.org/merge2/-/merge2-1.4.1.tgz",
-      "integrity": "sha512-8q7VEgMJW4J8tcfVPy8g09NcQwZdbwFEqhe/WZkoIzjn/3TGDwtOCYtXGxA3O8tPzpczCCDgv+P2P5y00ZJOOg==",
-      "dev": true,
+    "node_modules/mdast-util-find-and-replace/node_modules/escape-string-regexp": {
+      "version": "5.0.0",
+      "resolved": "https://registry.npmjs.org/escape-string-regexp/-/escape-string-regexp-5.0.0.tgz",
+      "integrity": "sha512-/veY75JbMK4j1yjvuUxuVsiS/hr/4iHs9FTT6cgTexxdE0Ly/glccBAkloH/DofkjRbZU3bnoj38mOmhkZ0lHw==",
       "license": "MIT",
       "engines": {
-        "node": ">= 8"
+        "node": ">=12"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
       }
     },
-    "node_modules/micromatch": {
-      "version": "4.0.8",
-      "resolved": "https://registry.npmjs.org/micromatch/-/micromatch-4.0.8.tgz",
-      "integrity": "sha512-PXwfBhYu0hBCPw8Dn0E+WDYb7af3dSLVWKi3HGv84IdF4TyFoC0ysxFd0Goxw7nSv4T/PzEJQxsYsEiFCKo2BA==",
-      "dev": true,
+    "node_modules/mdast-util-from-markdown": {
+      "version": "2.0.3",
+      "resolved": "https://registry.npmjs.org/mdast-util-from-markdown/-/mdast-util-from-markdown-2.0.3.tgz",
+      "integrity": "sha512-W4mAWTvSlKvf8L6J+VN9yLSqQ9AOAAvHuoDAmPkz4dHf553m5gVj2ejadHJhoJmcmxEnOv6Pa8XJhpxE93kb8Q==",
       "license": "MIT",
       "dependencies": {
-        "braces": "^3.0.3",
-        "picomatch": "^2.3.1"
+        "@types/mdast": "^4.0.0",
+        "@types/unist": "^3.0.0",
+        "decode-named-character-reference": "^1.0.0",
+        "devlop": "^1.0.0",
+        "mdast-util-to-string": "^4.0.0",
+        "micromark": "^4.0.0",
+        "micromark-util-decode-numeric-character-reference": "^2.0.0",
+        "micromark-util-decode-string": "^2.0.0",
+        "micromark-util-normalize-identifier": "^2.0.0",
+        "micromark-util-symbol": "^2.0.0",
+        "micromark-util-types": "^2.0.0",
+        "unist-util-stringify-position": "^4.0.0"
       },
-      "engines": {
-        "node": ">=8.6"
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
       }
     },
-    "node_modules/minimatch": {
-      "version": "3.1.2",
-      "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-3.1.2.tgz",
-      "integrity": "sha512-J7p63hRiAjw1NDEww1W7i37+ByIrOWO5XQQAzZ3VOcL0PNybwpfmV/N05zFAzwQ9USyEcX6t3UO+K5aqBQOIHw==",
-      "dev": true,
-      "license": "ISC",
+    "node_modules/mdast-util-gfm": {
+      "version": "3.1.0",
+      "resolved": "https://registry.npmjs.org/mdast-util-gfm/-/mdast-util-gfm-3.1.0.tgz",
+      "integrity": "sha512-0ulfdQOM3ysHhCJ1p06l0b0VKlhU0wuQs3thxZQagjcjPrlFRqY215uZGHHJan9GEAXd9MbfPjFJz+qMkVR6zQ==",
+      "license": "MIT",
       "dependencies": {
-        "brace-expansion": "^1.1.7"
+        "mdast-util-from-markdown": "^2.0.0",
+        "mdast-util-gfm-autolink-literal": "^2.0.0",
+        "mdast-util-gfm-footnote": "^2.0.0",
+        "mdast-util-gfm-strikethrough": "^2.0.0",
+        "mdast-util-gfm-table": "^2.0.0",
+        "mdast-util-gfm-task-list-item": "^2.0.0",
+        "mdast-util-to-markdown": "^2.0.0"
       },
-      "engines": {
-        "node": "*"
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
       }
     },
-    "node_modules/minimist": {
-      "version": "1.2.8",
-      "resolved": "https://registry.npmjs.org/minimist/-/minimist-1.2.8.tgz",
-      "integrity": "sha512-2yyAR8qBkN3YuheJanUpWC5U3bb5osDywNB8RzDVlDwDHbocAJveqqj1u8+SVD7jkWT4yvsHCpWqqWqAxb0zCA==",
-      "dev": true,
+    "node_modules/mdast-util-gfm-autolink-literal": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/mdast-util-gfm-autolink-literal/-/mdast-util-gfm-autolink-literal-2.0.1.tgz",
+      "integrity": "sha512-5HVP2MKaP6L+G6YaxPNjuL0BPrq9orG3TsrZ9YXbA3vDw/ACI4MEsnoDpn6ZNm7GnZgtAcONJyPhOP8tNJQavQ==",
       "license": "MIT",
+      "dependencies": {
+        "@types/mdast": "^4.0.0",
+        "ccount": "^2.0.0",
+        "devlop": "^1.0.0",
+        "mdast-util-find-and-replace": "^3.0.0",
+        "micromark-util-character": "^2.0.0"
+      },
       "funding": {
-        "url": "https://github.com/sponsors/ljharb"
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
       }
     },
-    "node_modules/motion": {
-      "version": "12.23.24",
-      "resolved": "https://registry.npmjs.org/motion/-/motion-12.23.24.tgz",
-      "integrity": "sha512-Rc5E7oe2YZ72N//S3QXGzbnXgqNrTESv8KKxABR20q2FLch9gHLo0JLyYo2hZ238bZ9Gx6cWhj9VO0IgwbMjCw==",
+    "node_modules/mdast-util-gfm-footnote": {
+      "version": "2.1.0",
+      "resolved": "https://registry.npmjs.org/mdast-util-gfm-footnote/-/mdast-util-gfm-footnote-2.1.0.tgz",
+      "integrity": "sha512-sqpDWlsHn7Ac9GNZQMeUzPQSMzR6Wv0WKRNvQRg0KqHh02fpTz69Qc1QSseNX29bhz1ROIyNyxExfawVKTm1GQ==",
       "license": "MIT",
       "dependencies": {
-        "framer-motion": "^12.23.24",
-        "tslib": "^2.4.0"
+        "@types/mdast": "^4.0.0",
+        "devlop": "^1.1.0",
+        "mdast-util-from-markdown": "^2.0.0",
+        "mdast-util-to-markdown": "^2.0.0",
+        "micromark-util-normalize-identifier": "^2.0.0"
       },
-      "peerDependencies": {
-        "@emotion/is-prop-valid": "*",
-        "react": "^18.0.0 || ^19.0.0",
-        "react-dom": "^18.0.0 || ^19.0.0"
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/mdast-util-gfm-strikethrough": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/mdast-util-gfm-strikethrough/-/mdast-util-gfm-strikethrough-2.0.0.tgz",
+      "integrity": "sha512-mKKb915TF+OC5ptj5bJ7WFRPdYtuHv0yTRxK2tJvi+BDqbkiG7h7u/9SI89nRAYcmap2xHQL9D+QG/6wSrTtXg==",
+      "license": "MIT",
+      "dependencies": {
+        "@types/mdast": "^4.0.0",
+        "mdast-util-from-markdown": "^2.0.0",
+        "mdast-util-to-markdown": "^2.0.0"
       },
-      "peerDependenciesMeta": {
-        "@emotion/is-prop-valid": {
-          "optional": true
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/mdast-util-gfm-table": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/mdast-util-gfm-table/-/mdast-util-gfm-table-2.0.0.tgz",
+      "integrity": "sha512-78UEvebzz/rJIxLvE7ZtDd/vIQ0RHv+3Mh5DR96p7cS7HsBhYIICDBCu8csTNWNO6tBWfqXPWekRuj2FNOGOZg==",
+      "license": "MIT",
+      "dependencies": {
+        "@types/mdast": "^4.0.0",
+        "devlop": "^1.0.0",
+        "markdown-table": "^3.0.0",
+        "mdast-util-from-markdown": "^2.0.0",
+        "mdast-util-to-markdown": "^2.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/mdast-util-gfm-task-list-item": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/mdast-util-gfm-task-list-item/-/mdast-util-gfm-task-list-item-2.0.0.tgz",
+      "integrity": "sha512-IrtvNvjxC1o06taBAVJznEnkiHxLFTzgonUdy8hzFVeDun0uTjxxrRGVaNFqkU1wJR3RBPEfsxmU6jDWPofrTQ==",
+      "license": "MIT",
+      "dependencies": {
+        "@types/mdast": "^4.0.0",
+        "devlop": "^1.0.0",
+        "mdast-util-from-markdown": "^2.0.0",
+        "mdast-util-to-markdown": "^2.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/mdast-util-mdx-expression": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/mdast-util-mdx-expression/-/mdast-util-mdx-expression-2.0.1.tgz",
+      "integrity": "sha512-J6f+9hUp+ldTZqKRSg7Vw5V6MqjATc+3E4gf3CFNcuZNWD8XdyI6zQ8GqH7f8169MM6P7hMBRDVGnn7oHB9kXQ==",
+      "license": "MIT",
+      "dependencies": {
+        "@types/estree-jsx": "^1.0.0",
+        "@types/hast": "^3.0.0",
+        "@types/mdast": "^4.0.0",
+        "devlop": "^1.0.0",
+        "mdast-util-from-markdown": "^2.0.0",
+        "mdast-util-to-markdown": "^2.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/mdast-util-mdx-jsx": {
+      "version": "3.2.0",
+      "resolved": "https://registry.npmjs.org/mdast-util-mdx-jsx/-/mdast-util-mdx-jsx-3.2.0.tgz",
+      "integrity": "sha512-lj/z8v0r6ZtsN/cGNNtemmmfoLAFZnjMbNyLzBafjzikOM+glrjNHPlf6lQDOTccj9n5b0PPihEBbhneMyGs1Q==",
+      "license": "MIT",
+      "dependencies": {
+        "@types/estree-jsx": "^1.0.0",
+        "@types/hast": "^3.0.0",
+        "@types/mdast": "^4.0.0",
+        "@types/unist": "^3.0.0",
+        "ccount": "^2.0.0",
+        "devlop": "^1.1.0",
+        "mdast-util-from-markdown": "^2.0.0",
+        "mdast-util-to-markdown": "^2.0.0",
+        "parse-entities": "^4.0.0",
+        "stringify-entities": "^4.0.0",
+        "unist-util-stringify-position": "^4.0.0",
+        "vfile-message": "^4.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/mdast-util-mdxjs-esm": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/mdast-util-mdxjs-esm/-/mdast-util-mdxjs-esm-2.0.1.tgz",
+      "integrity": "sha512-EcmOpxsZ96CvlP03NghtH1EsLtr0n9Tm4lPUJUBccV9RwUOneqSycg19n5HGzCf+10LozMRSObtVr3ee1WoHtg==",
+      "license": "MIT",
+      "dependencies": {
+        "@types/estree-jsx": "^1.0.0",
+        "@types/hast": "^3.0.0",
+        "@types/mdast": "^4.0.0",
+        "devlop": "^1.0.0",
+        "mdast-util-from-markdown": "^2.0.0",
+        "mdast-util-to-markdown": "^2.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/mdast-util-phrasing": {
+      "version": "4.1.0",
+      "resolved": "https://registry.npmjs.org/mdast-util-phrasing/-/mdast-util-phrasing-4.1.0.tgz",
+      "integrity": "sha512-TqICwyvJJpBwvGAMZjj4J2n0X8QWp21b9l0o7eXyVJ25YNWYbJDVIyD1bZXE6WtV6RmKJVYmQAKWa0zWOABz2w==",
+      "license": "MIT",
+      "dependencies": {
+        "@types/mdast": "^4.0.0",
+        "unist-util-is": "^6.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/mdast-util-to-hast": {
+      "version": "13.2.1",
+      "resolved": "https://registry.npmjs.org/mdast-util-to-hast/-/mdast-util-to-hast-13.2.1.tgz",
+      "integrity": "sha512-cctsq2wp5vTsLIcaymblUriiTcZd0CwWtCbLvrOzYCDZoWyMNV8sZ7krj09FSnsiJi3WVsHLM4k6Dq/yaPyCXA==",
+      "license": "MIT",
+      "dependencies": {
+        "@types/hast": "^3.0.0",
+        "@types/mdast": "^4.0.0",
+        "@ungap/structured-clone": "^1.0.0",
+        "devlop": "^1.0.0",
+        "micromark-util-sanitize-uri": "^2.0.0",
+        "trim-lines": "^3.0.0",
+        "unist-util-position": "^5.0.0",
+        "unist-util-visit": "^5.0.0",
+        "vfile": "^6.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/mdast-util-to-markdown": {
+      "version": "2.1.2",
+      "resolved": "https://registry.npmjs.org/mdast-util-to-markdown/-/mdast-util-to-markdown-2.1.2.tgz",
+      "integrity": "sha512-xj68wMTvGXVOKonmog6LwyJKrYXZPvlwabaryTjLh9LuvovB/KAH+kvi8Gjj+7rJjsFi23nkUxRQv1KqSroMqA==",
+      "license": "MIT",
+      "dependencies": {
+        "@types/mdast": "^4.0.0",
+        "@types/unist": "^3.0.0",
+        "longest-streak": "^3.0.0",
+        "mdast-util-phrasing": "^4.0.0",
+        "mdast-util-to-string": "^4.0.0",
+        "micromark-util-classify-character": "^2.0.0",
+        "micromark-util-decode-string": "^2.0.0",
+        "unist-util-visit": "^5.0.0",
+        "zwitch": "^2.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/mdast-util-to-string": {
+      "version": "4.0.0",
+      "resolved": "https://registry.npmjs.org/mdast-util-to-string/-/mdast-util-to-string-4.0.0.tgz",
+      "integrity": "sha512-0H44vDimn51F0YwvxSJSm0eCDOJTRlmN0R1yBh4HLj9wiV1Dn0QoXGbvFAWj2hSItVTlCmBF1hqKlIyUBVFLPg==",
+      "license": "MIT",
+      "dependencies": {
+        "@types/mdast": "^4.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/mdn-data": {
+      "version": "2.0.30",
+      "resolved": "https://registry.npmjs.org/mdn-data/-/mdn-data-2.0.30.tgz",
+      "integrity": "sha512-GaqWWShW4kv/G9IEucWScBx9G1/vsFZZJUO+tD26M8J8z3Kw5RDQjaoZe03YAClgeS/SWPOcb4nkFBTEi5DUEA==",
+      "license": "CC0-1.0"
+    },
+    "node_modules/merge2": {
+      "version": "1.4.1",
+      "resolved": "https://registry.npmjs.org/merge2/-/merge2-1.4.1.tgz",
+      "integrity": "sha512-8q7VEgMJW4J8tcfVPy8g09NcQwZdbwFEqhe/WZkoIzjn/3TGDwtOCYtXGxA3O8tPzpczCCDgv+P2P5y00ZJOOg==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">= 8"
+      }
+    },
+    "node_modules/micromark": {
+      "version": "4.0.2",
+      "resolved": "https://registry.npmjs.org/micromark/-/micromark-4.0.2.tgz",
+      "integrity": "sha512-zpe98Q6kvavpCr1NPVSCMebCKfD7CA2NqZ+rykeNhONIJBpc1tFKt9hucLGwha3jNTNI8lHpctWJWoimVF4PfA==",
+      "funding": [
+        {
+          "type": "GitHub Sponsors",
+          "url": "https://github.com/sponsors/unifiedjs"
+        },
+        {
+          "type": "OpenCollective",
+          "url": "https://opencollective.com/unified"
+        }
+      ],
+      "license": "MIT",
+      "dependencies": {
+        "@types/debug": "^4.0.0",
+        "debug": "^4.0.0",
+        "decode-named-character-reference": "^1.0.0",
+        "devlop": "^1.0.0",
+        "micromark-core-commonmark": "^2.0.0",
+        "micromark-factory-space": "^2.0.0",
+        "micromark-util-character": "^2.0.0",
+        "micromark-util-chunked": "^2.0.0",
+        "micromark-util-combine-extensions": "^2.0.0",
+        "micromark-util-decode-numeric-character-reference": "^2.0.0",
+        "micromark-util-encode": "^2.0.0",
+        "micromark-util-normalize-identifier": "^2.0.0",
+        "micromark-util-resolve-all": "^2.0.0",
+        "micromark-util-sanitize-uri": "^2.0.0",
+        "micromark-util-subtokenize": "^2.0.0",
+        "micromark-util-symbol": "^2.0.0",
+        "micromark-util-types": "^2.0.0"
+      }
+    },
+    "node_modules/micromark-core-commonmark": {
+      "version": "2.0.3",
+      "resolved": "https://registry.npmjs.org/micromark-core-commonmark/-/micromark-core-commonmark-2.0.3.tgz",
+      "integrity": "sha512-RDBrHEMSxVFLg6xvnXmb1Ayr2WzLAWjeSATAoxwKYJV94TeNavgoIdA0a9ytzDSVzBy2YKFK+emCPOEibLeCrg==",
+      "funding": [
+        {
+          "type": "GitHub Sponsors",
+          "url": "https://github.com/sponsors/unifiedjs"
+        },
+        {
+          "type": "OpenCollective",
+          "url": "https://opencollective.com/unified"
+        }
+      ],
+      "license": "MIT",
+      "dependencies": {
+        "decode-named-character-reference": "^1.0.0",
+        "devlop": "^1.0.0",
+        "micromark-factory-destination": "^2.0.0",
+        "micromark-factory-label": "^2.0.0",
+        "micromark-factory-space": "^2.0.0",
+        "micromark-factory-title": "^2.0.0",
+        "micromark-factory-whitespace": "^2.0.0",
+        "micromark-util-character": "^2.0.0",
+        "micromark-util-chunked": "^2.0.0",
+        "micromark-util-classify-character": "^2.0.0",
+        "micromark-util-html-tag-name": "^2.0.0",
+        "micromark-util-normalize-identifier": "^2.0.0",
+        "micromark-util-resolve-all": "^2.0.0",
+        "micromark-util-subtokenize": "^2.0.0",
+        "micromark-util-symbol": "^2.0.0",
+        "micromark-util-types": "^2.0.0"
+      }
+    },
+    "node_modules/micromark-extension-gfm": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/micromark-extension-gfm/-/micromark-extension-gfm-3.0.0.tgz",
+      "integrity": "sha512-vsKArQsicm7t0z2GugkCKtZehqUm31oeGBV/KVSorWSy8ZlNAv7ytjFhvaryUiCUJYqs+NoE6AFhpQvBTM6Q4w==",
+      "license": "MIT",
+      "dependencies": {
+        "micromark-extension-gfm-autolink-literal": "^2.0.0",
+        "micromark-extension-gfm-footnote": "^2.0.0",
+        "micromark-extension-gfm-strikethrough": "^2.0.0",
+        "micromark-extension-gfm-table": "^2.0.0",
+        "micromark-extension-gfm-tagfilter": "^2.0.0",
+        "micromark-extension-gfm-task-list-item": "^2.0.0",
+        "micromark-util-combine-extensions": "^2.0.0",
+        "micromark-util-types": "^2.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/micromark-extension-gfm-autolink-literal": {
+      "version": "2.1.0",
+      "resolved": "https://registry.npmjs.org/micromark-extension-gfm-autolink-literal/-/micromark-extension-gfm-autolink-literal-2.1.0.tgz",
+      "integrity": "sha512-oOg7knzhicgQ3t4QCjCWgTmfNhvQbDDnJeVu9v81r7NltNCVmhPy1fJRX27pISafdjL+SVc4d3l48Gb6pbRypw==",
+      "license": "MIT",
+      "dependencies": {
+        "micromark-util-character": "^2.0.0",
+        "micromark-util-sanitize-uri": "^2.0.0",
+        "micromark-util-symbol": "^2.0.0",
+        "micromark-util-types": "^2.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/micromark-extension-gfm-footnote": {
+      "version": "2.1.0",
+      "resolved": "https://registry.npmjs.org/micromark-extension-gfm-footnote/-/micromark-extension-gfm-footnote-2.1.0.tgz",
+      "integrity": "sha512-/yPhxI1ntnDNsiHtzLKYnE3vf9JZ6cAisqVDauhp4CEHxlb4uoOTxOCJ+9s51bIB8U1N1FJ1RXOKTIlD5B/gqw==",
+      "license": "MIT",
+      "dependencies": {
+        "devlop": "^1.0.0",
+        "micromark-core-commonmark": "^2.0.0",
+        "micromark-factory-space": "^2.0.0",
+        "micromark-util-character": "^2.0.0",
+        "micromark-util-normalize-identifier": "^2.0.0",
+        "micromark-util-sanitize-uri": "^2.0.0",
+        "micromark-util-symbol": "^2.0.0",
+        "micromark-util-types": "^2.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/micromark-extension-gfm-strikethrough": {
+      "version": "2.1.0",
+      "resolved": "https://registry.npmjs.org/micromark-extension-gfm-strikethrough/-/micromark-extension-gfm-strikethrough-2.1.0.tgz",
+      "integrity": "sha512-ADVjpOOkjz1hhkZLlBiYA9cR2Anf8F4HqZUO6e5eDcPQd0Txw5fxLzzxnEkSkfnD0wziSGiv7sYhk/ktvbf1uw==",
+      "license": "MIT",
+      "dependencies": {
+        "devlop": "^1.0.0",
+        "micromark-util-chunked": "^2.0.0",
+        "micromark-util-classify-character": "^2.0.0",
+        "micromark-util-resolve-all": "^2.0.0",
+        "micromark-util-symbol": "^2.0.0",
+        "micromark-util-types": "^2.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/micromark-extension-gfm-table": {
+      "version": "2.1.1",
+      "resolved": "https://registry.npmjs.org/micromark-extension-gfm-table/-/micromark-extension-gfm-table-2.1.1.tgz",
+      "integrity": "sha512-t2OU/dXXioARrC6yWfJ4hqB7rct14e8f7m0cbI5hUmDyyIlwv5vEtooptH8INkbLzOatzKuVbQmAYcbWoyz6Dg==",
+      "license": "MIT",
+      "dependencies": {
+        "devlop": "^1.0.0",
+        "micromark-factory-space": "^2.0.0",
+        "micromark-util-character": "^2.0.0",
+        "micromark-util-symbol": "^2.0.0",
+        "micromark-util-types": "^2.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/micromark-extension-gfm-tagfilter": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/micromark-extension-gfm-tagfilter/-/micromark-extension-gfm-tagfilter-2.0.0.tgz",
+      "integrity": "sha512-xHlTOmuCSotIA8TW1mDIM6X2O1SiX5P9IuDtqGonFhEK0qgRI4yeC6vMxEV2dgyr2TiD+2PQ10o+cOhdVAcwfg==",
+      "license": "MIT",
+      "dependencies": {
+        "micromark-util-types": "^2.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/micromark-extension-gfm-task-list-item": {
+      "version": "2.1.0",
+      "resolved": "https://registry.npmjs.org/micromark-extension-gfm-task-list-item/-/micromark-extension-gfm-task-list-item-2.1.0.tgz",
+      "integrity": "sha512-qIBZhqxqI6fjLDYFTBIa4eivDMnP+OZqsNwmQ3xNLE4Cxwc+zfQEfbs6tzAo2Hjq+bh6q5F+Z8/cksrLFYWQQw==",
+      "license": "MIT",
+      "dependencies": {
+        "devlop": "^1.0.0",
+        "micromark-factory-space": "^2.0.0",
+        "micromark-util-character": "^2.0.0",
+        "micromark-util-symbol": "^2.0.0",
+        "micromark-util-types": "^2.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/micromark-factory-destination": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/micromark-factory-destination/-/micromark-factory-destination-2.0.1.tgz",
+      "integrity": "sha512-Xe6rDdJlkmbFRExpTOmRj9N3MaWmbAgdpSrBQvCFqhezUn4AHqJHbaEnfbVYYiexVSs//tqOdY/DxhjdCiJnIA==",
+      "funding": [
+        {
+          "type": "GitHub Sponsors",
+          "url": "https://github.com/sponsors/unifiedjs"
+        },
+        {
+          "type": "OpenCollective",
+          "url": "https://opencollective.com/unified"
+        }
+      ],
+      "license": "MIT",
+      "dependencies": {
+        "micromark-util-character": "^2.0.0",
+        "micromark-util-symbol": "^2.0.0",
+        "micromark-util-types": "^2.0.0"
+      }
+    },
+    "node_modules/micromark-factory-label": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/micromark-factory-label/-/micromark-factory-label-2.0.1.tgz",
+      "integrity": "sha512-VFMekyQExqIW7xIChcXn4ok29YE3rnuyveW3wZQWWqF4Nv9Wk5rgJ99KzPvHjkmPXF93FXIbBp6YdW3t71/7Vg==",
+      "funding": [
+        {
+          "type": "GitHub Sponsors",
+          "url": "https://github.com/sponsors/unifiedjs"
+        },
+        {
+          "type": "OpenCollective",
+          "url": "https://opencollective.com/unified"
+        }
+      ],
+      "license": "MIT",
+      "dependencies": {
+        "devlop": "^1.0.0",
+        "micromark-util-character": "^2.0.0",
+        "micromark-util-symbol": "^2.0.0",
+        "micromark-util-types": "^2.0.0"
+      }
+    },
+    "node_modules/micromark-factory-space": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/micromark-factory-space/-/micromark-factory-space-2.0.1.tgz",
+      "integrity": "sha512-zRkxjtBxxLd2Sc0d+fbnEunsTj46SWXgXciZmHq0kDYGnck/ZSGj9/wULTV95uoeYiK5hRXP2mJ98Uo4cq/LQg==",
+      "funding": [
+        {
+          "type": "GitHub Sponsors",
+          "url": "https://github.com/sponsors/unifiedjs"
+        },
+        {
+          "type": "OpenCollective",
+          "url": "https://opencollective.com/unified"
+        }
+      ],
+      "license": "MIT",
+      "dependencies": {
+        "micromark-util-character": "^2.0.0",
+        "micromark-util-types": "^2.0.0"
+      }
+    },
+    "node_modules/micromark-factory-title": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/micromark-factory-title/-/micromark-factory-title-2.0.1.tgz",
+      "integrity": "sha512-5bZ+3CjhAd9eChYTHsjy6TGxpOFSKgKKJPJxr293jTbfry2KDoWkhBb6TcPVB4NmzaPhMs1Frm9AZH7OD4Cjzw==",
+      "funding": [
+        {
+          "type": "GitHub Sponsors",
+          "url": "https://github.com/sponsors/unifiedjs"
+        },
+        {
+          "type": "OpenCollective",
+          "url": "https://opencollective.com/unified"
+        }
+      ],
+      "license": "MIT",
+      "dependencies": {
+        "micromark-factory-space": "^2.0.0",
+        "micromark-util-character": "^2.0.0",
+        "micromark-util-symbol": "^2.0.0",
+        "micromark-util-types": "^2.0.0"
+      }
+    },
+    "node_modules/micromark-factory-whitespace": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/micromark-factory-whitespace/-/micromark-factory-whitespace-2.0.1.tgz",
+      "integrity": "sha512-Ob0nuZ3PKt/n0hORHyvoD9uZhr+Za8sFoP+OnMcnWK5lngSzALgQYKMr9RJVOWLqQYuyn6ulqGWSXdwf6F80lQ==",
+      "funding": [
+        {
+          "type": "GitHub Sponsors",
+          "url": "https://github.com/sponsors/unifiedjs"
+        },
+        {
+          "type": "OpenCollective",
+          "url": "https://opencollective.com/unified"
+        }
+      ],
+      "license": "MIT",
+      "dependencies": {
+        "micromark-factory-space": "^2.0.0",
+        "micromark-util-character": "^2.0.0",
+        "micromark-util-symbol": "^2.0.0",
+        "micromark-util-types": "^2.0.0"
+      }
+    },
+    "node_modules/micromark-util-character": {
+      "version": "2.1.1",
+      "resolved": "https://registry.npmjs.org/micromark-util-character/-/micromark-util-character-2.1.1.tgz",
+      "integrity": "sha512-wv8tdUTJ3thSFFFJKtpYKOYiGP2+v96Hvk4Tu8KpCAsTMs6yi+nVmGh1syvSCsaxz45J6Jbw+9DD6g97+NV67Q==",
+      "funding": [
+        {
+          "type": "GitHub Sponsors",
+          "url": "https://github.com/sponsors/unifiedjs"
+        },
+        {
+          "type": "OpenCollective",
+          "url": "https://opencollective.com/unified"
+        }
+      ],
+      "license": "MIT",
+      "dependencies": {
+        "micromark-util-symbol": "^2.0.0",
+        "micromark-util-types": "^2.0.0"
+      }
+    },
+    "node_modules/micromark-util-chunked": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/micromark-util-chunked/-/micromark-util-chunked-2.0.1.tgz",
+      "integrity": "sha512-QUNFEOPELfmvv+4xiNg2sRYeS/P84pTW0TCgP5zc9FpXetHY0ab7SxKyAQCNCc1eK0459uoLI1y5oO5Vc1dbhA==",
+      "funding": [
+        {
+          "type": "GitHub Sponsors",
+          "url": "https://github.com/sponsors/unifiedjs"
+        },
+        {
+          "type": "OpenCollective",
+          "url": "https://opencollective.com/unified"
+        }
+      ],
+      "license": "MIT",
+      "dependencies": {
+        "micromark-util-symbol": "^2.0.0"
+      }
+    },
+    "node_modules/micromark-util-classify-character": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/micromark-util-classify-character/-/micromark-util-classify-character-2.0.1.tgz",
+      "integrity": "sha512-K0kHzM6afW/MbeWYWLjoHQv1sgg2Q9EccHEDzSkxiP/EaagNzCm7T/WMKZ3rjMbvIpvBiZgwR3dKMygtA4mG1Q==",
+      "funding": [
+        {
+          "type": "GitHub Sponsors",
+          "url": "https://github.com/sponsors/unifiedjs"
+        },
+        {
+          "type": "OpenCollective",
+          "url": "https://opencollective.com/unified"
+        }
+      ],
+      "license": "MIT",
+      "dependencies": {
+        "micromark-util-character": "^2.0.0",
+        "micromark-util-symbol": "^2.0.0",
+        "micromark-util-types": "^2.0.0"
+      }
+    },
+    "node_modules/micromark-util-combine-extensions": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/micromark-util-combine-extensions/-/micromark-util-combine-extensions-2.0.1.tgz",
+      "integrity": "sha512-OnAnH8Ujmy59JcyZw8JSbK9cGpdVY44NKgSM7E9Eh7DiLS2E9RNQf0dONaGDzEG9yjEl5hcqeIsj4hfRkLH/Bg==",
+      "funding": [
+        {
+          "type": "GitHub Sponsors",
+          "url": "https://github.com/sponsors/unifiedjs"
+        },
+        {
+          "type": "OpenCollective",
+          "url": "https://opencollective.com/unified"
+        }
+      ],
+      "license": "MIT",
+      "dependencies": {
+        "micromark-util-chunked": "^2.0.0",
+        "micromark-util-types": "^2.0.0"
+      }
+    },
+    "node_modules/micromark-util-decode-numeric-character-reference": {
+      "version": "2.0.2",
+      "resolved": "https://registry.npmjs.org/micromark-util-decode-numeric-character-reference/-/micromark-util-decode-numeric-character-reference-2.0.2.tgz",
+      "integrity": "sha512-ccUbYk6CwVdkmCQMyr64dXz42EfHGkPQlBj5p7YVGzq8I7CtjXZJrubAYezf7Rp+bjPseiROqe7G6foFd+lEuw==",
+      "funding": [
+        {
+          "type": "GitHub Sponsors",
+          "url": "https://github.com/sponsors/unifiedjs"
+        },
+        {
+          "type": "OpenCollective",
+          "url": "https://opencollective.com/unified"
+        }
+      ],
+      "license": "MIT",
+      "dependencies": {
+        "micromark-util-symbol": "^2.0.0"
+      }
+    },
+    "node_modules/micromark-util-decode-string": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/micromark-util-decode-string/-/micromark-util-decode-string-2.0.1.tgz",
+      "integrity": "sha512-nDV/77Fj6eH1ynwscYTOsbK7rR//Uj0bZXBwJZRfaLEJ1iGBR6kIfNmlNqaqJf649EP0F3NWNdeJi03elllNUQ==",
+      "funding": [
+        {
+          "type": "GitHub Sponsors",
+          "url": "https://github.com/sponsors/unifiedjs"
+        },
+        {
+          "type": "OpenCollective",
+          "url": "https://opencollective.com/unified"
+        }
+      ],
+      "license": "MIT",
+      "dependencies": {
+        "decode-named-character-reference": "^1.0.0",
+        "micromark-util-character": "^2.0.0",
+        "micromark-util-decode-numeric-character-reference": "^2.0.0",
+        "micromark-util-symbol": "^2.0.0"
+      }
+    },
+    "node_modules/micromark-util-encode": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/micromark-util-encode/-/micromark-util-encode-2.0.1.tgz",
+      "integrity": "sha512-c3cVx2y4KqUnwopcO9b/SCdo2O67LwJJ/UyqGfbigahfegL9myoEFoDYZgkT7f36T0bLrM9hZTAaAyH+PCAXjw==",
+      "funding": [
+        {
+          "type": "GitHub Sponsors",
+          "url": "https://github.com/sponsors/unifiedjs"
+        },
+        {
+          "type": "OpenCollective",
+          "url": "https://opencollective.com/unified"
+        }
+      ],
+      "license": "MIT"
+    },
+    "node_modules/micromark-util-html-tag-name": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/micromark-util-html-tag-name/-/micromark-util-html-tag-name-2.0.1.tgz",
+      "integrity": "sha512-2cNEiYDhCWKI+Gs9T0Tiysk136SnR13hhO8yW6BGNyhOC4qYFnwF1nKfD3HFAIXA5c45RrIG1ub11GiXeYd1xA==",
+      "funding": [
+        {
+          "type": "GitHub Sponsors",
+          "url": "https://github.com/sponsors/unifiedjs"
+        },
+        {
+          "type": "OpenCollective",
+          "url": "https://opencollective.com/unified"
+        }
+      ],
+      "license": "MIT"
+    },
+    "node_modules/micromark-util-normalize-identifier": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/micromark-util-normalize-identifier/-/micromark-util-normalize-identifier-2.0.1.tgz",
+      "integrity": "sha512-sxPqmo70LyARJs0w2UclACPUUEqltCkJ6PhKdMIDuJ3gSf/Q+/GIe3WKl0Ijb/GyH9lOpUkRAO2wp0GVkLvS9Q==",
+      "funding": [
+        {
+          "type": "GitHub Sponsors",
+          "url": "https://github.com/sponsors/unifiedjs"
+        },
+        {
+          "type": "OpenCollective",
+          "url": "https://opencollective.com/unified"
+        }
+      ],
+      "license": "MIT",
+      "dependencies": {
+        "micromark-util-symbol": "^2.0.0"
+      }
+    },
+    "node_modules/micromark-util-resolve-all": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/micromark-util-resolve-all/-/micromark-util-resolve-all-2.0.1.tgz",
+      "integrity": "sha512-VdQyxFWFT2/FGJgwQnJYbe1jjQoNTS4RjglmSjTUlpUMa95Htx9NHeYW4rGDJzbjvCsl9eLjMQwGeElsqmzcHg==",
+      "funding": [
+        {
+          "type": "GitHub Sponsors",
+          "url": "https://github.com/sponsors/unifiedjs"
+        },
+        {
+          "type": "OpenCollective",
+          "url": "https://opencollective.com/unified"
+        }
+      ],
+      "license": "MIT",
+      "dependencies": {
+        "micromark-util-types": "^2.0.0"
+      }
+    },
+    "node_modules/micromark-util-sanitize-uri": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/micromark-util-sanitize-uri/-/micromark-util-sanitize-uri-2.0.1.tgz",
+      "integrity": "sha512-9N9IomZ/YuGGZZmQec1MbgxtlgougxTodVwDzzEouPKo3qFWvymFHWcnDi2vzV1ff6kas9ucW+o3yzJK9YB1AQ==",
+      "funding": [
+        {
+          "type": "GitHub Sponsors",
+          "url": "https://github.com/sponsors/unifiedjs"
+        },
+        {
+          "type": "OpenCollective",
+          "url": "https://opencollective.com/unified"
+        }
+      ],
+      "license": "MIT",
+      "dependencies": {
+        "micromark-util-character": "^2.0.0",
+        "micromark-util-encode": "^2.0.0",
+        "micromark-util-symbol": "^2.0.0"
+      }
+    },
+    "node_modules/micromark-util-subtokenize": {
+      "version": "2.1.0",
+      "resolved": "https://registry.npmjs.org/micromark-util-subtokenize/-/micromark-util-subtokenize-2.1.0.tgz",
+      "integrity": "sha512-XQLu552iSctvnEcgXw6+Sx75GflAPNED1qx7eBJ+wydBb2KCbRZe+NwvIEEMM83uml1+2WSXpBAcp9IUCgCYWA==",
+      "funding": [
+        {
+          "type": "GitHub Sponsors",
+          "url": "https://github.com/sponsors/unifiedjs"
+        },
+        {
+          "type": "OpenCollective",
+          "url": "https://opencollective.com/unified"
+        }
+      ],
+      "license": "MIT",
+      "dependencies": {
+        "devlop": "^1.0.0",
+        "micromark-util-chunked": "^2.0.0",
+        "micromark-util-symbol": "^2.0.0",
+        "micromark-util-types": "^2.0.0"
+      }
+    },
+    "node_modules/micromark-util-symbol": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/micromark-util-symbol/-/micromark-util-symbol-2.0.1.tgz",
+      "integrity": "sha512-vs5t8Apaud9N28kgCrRUdEed4UJ+wWNvicHLPxCa9ENlYuAY31M0ETy5y1vA33YoNPDFTghEbnh6efaE8h4x0Q==",
+      "funding": [
+        {
+          "type": "GitHub Sponsors",
+          "url": "https://github.com/sponsors/unifiedjs"
+        },
+        {
+          "type": "OpenCollective",
+          "url": "https://opencollective.com/unified"
+        }
+      ],
+      "license": "MIT"
+    },
+    "node_modules/micromark-util-types": {
+      "version": "2.0.2",
+      "resolved": "https://registry.npmjs.org/micromark-util-types/-/micromark-util-types-2.0.2.tgz",
+      "integrity": "sha512-Yw0ECSpJoViF1qTU4DC6NwtC4aWGt1EkzaQB8KPPyCRR8z9TWeV0HbEFGTO+ZY1wB22zmxnJqhPyTpOVCpeHTA==",
+      "funding": [
+        {
+          "type": "GitHub Sponsors",
+          "url": "https://github.com/sponsors/unifiedjs"
+        },
+        {
+          "type": "OpenCollective",
+          "url": "https://opencollective.com/unified"
+        }
+      ],
+      "license": "MIT"
+    },
+    "node_modules/micromatch": {
+      "version": "4.0.8",
+      "resolved": "https://registry.npmjs.org/micromatch/-/micromatch-4.0.8.tgz",
+      "integrity": "sha512-PXwfBhYu0hBCPw8Dn0E+WDYb7af3dSLVWKi3HGv84IdF4TyFoC0ysxFd0Goxw7nSv4T/PzEJQxsYsEiFCKo2BA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "braces": "^3.0.3",
+        "picomatch": "^2.3.1"
+      },
+      "engines": {
+        "node": ">=8.6"
+      }
+    },
+    "node_modules/minimatch": {
+      "version": "3.1.2",
+      "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-3.1.2.tgz",
+      "integrity": "sha512-J7p63hRiAjw1NDEww1W7i37+ByIrOWO5XQQAzZ3VOcL0PNybwpfmV/N05zFAzwQ9USyEcX6t3UO+K5aqBQOIHw==",
+      "dev": true,
+      "license": "ISC",
+      "dependencies": {
+        "brace-expansion": "^1.1.7"
+      },
+      "engines": {
+        "node": "*"
+      }
+    },
+    "node_modules/minimist": {
+      "version": "1.2.8",
+      "resolved": "https://registry.npmjs.org/minimist/-/minimist-1.2.8.tgz",
+      "integrity": "sha512-2yyAR8qBkN3YuheJanUpWC5U3bb5osDywNB8RzDVlDwDHbocAJveqqj1u8+SVD7jkWT4yvsHCpWqqWqAxb0zCA==",
+      "dev": true,
+      "license": "MIT",
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/motion": {
+      "version": "12.23.24",
+      "resolved": "https://registry.npmjs.org/motion/-/motion-12.23.24.tgz",
+      "integrity": "sha512-Rc5E7oe2YZ72N//S3QXGzbnXgqNrTESv8KKxABR20q2FLch9gHLo0JLyYo2hZ238bZ9Gx6cWhj9VO0IgwbMjCw==",
+      "license": "MIT",
+      "dependencies": {
+        "framer-motion": "^12.23.24",
+        "tslib": "^2.4.0"
+      },
+      "peerDependencies": {
+        "@emotion/is-prop-valid": "*",
+        "react": "^18.0.0 || ^19.0.0",
+        "react-dom": "^18.0.0 || ^19.0.0"
+      },
+      "peerDependenciesMeta": {
+        "@emotion/is-prop-valid": {
+          "optional": true
         },
         "react": {
           "optional": true
@@ -7861,6 +9028,31 @@
         "node": ">=6"
       }
     },
+    "node_modules/parse-entities": {
+      "version": "4.0.2",
+      "resolved": "https://registry.npmjs.org/parse-entities/-/parse-entities-4.0.2.tgz",
+      "integrity": "sha512-GG2AQYWoLgL877gQIKeRPGO1xF9+eG1ujIb5soS5gPvLQ1y2o8FL90w2QWNdf9I361Mpp7726c+lj3U0qK1uGw==",
+      "license": "MIT",
+      "dependencies": {
+        "@types/unist": "^2.0.0",
+        "character-entities-legacy": "^3.0.0",
+        "character-reference-invalid": "^2.0.0",
+        "decode-named-character-reference": "^1.0.0",
+        "is-alphanumerical": "^2.0.0",
+        "is-decimal": "^2.0.0",
+        "is-hexadecimal": "^2.0.0"
+      },
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/wooorm"
+      }
+    },
+    "node_modules/parse-entities/node_modules/@types/unist": {
+      "version": "2.0.11",
+      "resolved": "https://registry.npmjs.org/@types/unist/-/unist-2.0.11.tgz",
+      "integrity": "sha512-CmBKiL6NNo/OqgmMn95Fk9Whlp2mtvIv+KNpQKN2F4SjvrEesubTRWGYSg+BnWZOnlCaSTU1sMpsBOzgbYhnsA==",
+      "license": "MIT"
+    },
     "node_modules/parse-json": {
       "version": "5.2.0",
       "resolved": "https://registry.npmjs.org/parse-json/-/parse-json-5.2.0.tgz",
@@ -7993,6 +9185,16 @@
         "react-is": "^16.13.1"
       }
     },
+    "node_modules/property-information": {
+      "version": "7.1.0",
+      "resolved": "https://registry.npmjs.org/property-information/-/property-information-7.1.0.tgz",
+      "integrity": "sha512-TwEZ+X+yCJmYfL7TPUOcvBZ4QfoT5YenQiJuX//0th53DE6w0xxLEtfK3iyryQFddXuvkIk51EEgrJQ0WJkOmQ==",
+      "license": "MIT",
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/wooorm"
+      }
+    },
     "node_modules/punycode": {
       "version": "2.3.1",
       "resolved": "https://registry.npmjs.org/punycode/-/punycode-2.3.1.tgz",
@@ -8077,6 +9279,33 @@
       "integrity": "sha512-24e6ynE2H+OKt4kqsOvNd8kBpV65zoxbA4BVsEOB3ARVWQki/DHzaUoC5KuON/BiccDaCCTZBuOcfZs70kR8bQ==",
       "license": "MIT"
     },
+    "node_modules/react-markdown": {
+      "version": "10.1.0",
+      "resolved": "https://registry.npmjs.org/react-markdown/-/react-markdown-10.1.0.tgz",
+      "integrity": "sha512-qKxVopLT/TyA6BX3Ue5NwabOsAzm0Q7kAPwq6L+wWDwisYs7R8vZ0nRXqq6rkueboxpkjvLGU9fWifiX/ZZFxQ==",
+      "license": "MIT",
+      "dependencies": {
+        "@types/hast": "^3.0.0",
+        "@types/mdast": "^4.0.0",
+        "devlop": "^1.0.0",
+        "hast-util-to-jsx-runtime": "^2.0.0",
+        "html-url-attributes": "^3.0.0",
+        "mdast-util-to-hast": "^13.0.0",
+        "remark-parse": "^11.0.0",
+        "remark-rehype": "^11.0.0",
+        "unified": "^11.0.0",
+        "unist-util-visit": "^5.0.0",
+        "vfile": "^6.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      },
+      "peerDependencies": {
+        "@types/react": ">=18",
+        "react": ">=18"
+      }
+    },
     "node_modules/react-remove-scroll": {
       "version": "2.7.1",
       "resolved": "https://registry.npmjs.org/react-remove-scroll/-/react-remove-scroll-2.7.1.tgz",
@@ -8258,6 +9487,86 @@
         "regjsparser": "bin/parser"
       }
     },
+    "node_modules/rehype-sanitize": {
+      "version": "6.0.0",
+      "resolved": "https://registry.npmjs.org/rehype-sanitize/-/rehype-sanitize-6.0.0.tgz",
+      "integrity": "sha512-CsnhKNsyI8Tub6L4sm5ZFsme4puGfc6pYylvXo1AeqaGbjOYyzNv3qZPwvs0oMJ39eryyeOdmxwUIo94IpEhqg==",
+      "license": "MIT",
+      "dependencies": {
+        "@types/hast": "^3.0.0",
+        "hast-util-sanitize": "^5.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/remark-gfm": {
+      "version": "4.0.1",
+      "resolved": "https://registry.npmjs.org/remark-gfm/-/remark-gfm-4.0.1.tgz",
+      "integrity": "sha512-1quofZ2RQ9EWdeN34S79+KExV1764+wCUGop5CPL1WGdD0ocPpu91lzPGbwWMECpEpd42kJGQwzRfyov9j4yNg==",
+      "license": "MIT",
+      "dependencies": {
+        "@types/mdast": "^4.0.0",
+        "mdast-util-gfm": "^3.0.0",
+        "micromark-extension-gfm": "^3.0.0",
+        "remark-parse": "^11.0.0",
+        "remark-stringify": "^11.0.0",
+        "unified": "^11.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/remark-parse": {
+      "version": "11.0.0",
+      "resolved": "https://registry.npmjs.org/remark-parse/-/remark-parse-11.0.0.tgz",
+      "integrity": "sha512-FCxlKLNGknS5ba/1lmpYijMUzX2esxW5xQqjWxw2eHFfS2MSdaHVINFmhjo+qN1WhZhNimq0dZATN9pH0IDrpA==",
+      "license": "MIT",
+      "dependencies": {
+        "@types/mdast": "^4.0.0",
+        "mdast-util-from-markdown": "^2.0.0",
+        "micromark-util-types": "^2.0.0",
+        "unified": "^11.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/remark-rehype": {
+      "version": "11.1.2",
+      "resolved": "https://registry.npmjs.org/remark-rehype/-/remark-rehype-11.1.2.tgz",
+      "integrity": "sha512-Dh7l57ianaEoIpzbp0PC9UKAdCSVklD8E5Rpw7ETfbTl3FqcOOgq5q2LVDhgGCkaBv7p24JXikPdvhhmHvKMsw==",
+      "license": "MIT",
+      "dependencies": {
+        "@types/hast": "^3.0.0",
+        "@types/mdast": "^4.0.0",
+        "mdast-util-to-hast": "^13.0.0",
+        "unified": "^11.0.0",
+        "vfile": "^6.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/remark-stringify": {
+      "version": "11.0.0",
+      "resolved": "https://registry.npmjs.org/remark-stringify/-/remark-stringify-11.0.0.tgz",
+      "integrity": "sha512-1OSmLd3awB/t8qdoEOMazZkNsfVTeY4fTsgzcQFdXNq8ToTN4ZGwrMnlda4K6smTFKD+GRV6O48i6Z4iKgPPpw==",
+      "license": "MIT",
+      "dependencies": {
+        "@types/mdast": "^4.0.0",
+        "mdast-util-to-markdown": "^2.0.0",
+        "unified": "^11.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
     "node_modules/resolve": {
       "version": "1.22.11",
       "resolved": "https://registry.npmjs.org/resolve/-/resolve-1.22.11.tgz",
@@ -8627,6 +9936,16 @@
         "node": ">=0.10.0"
       }
     },
+    "node_modules/space-separated-tokens": {
+      "version": "2.0.2",
+      "resolved": "https://registry.npmjs.org/space-separated-tokens/-/space-separated-tokens-2.0.2.tgz",
+      "integrity": "sha512-PEGlAwrG8yXGXRjW32fGbg66JAlOAwbObuqVoJpv/mRgoWDQfgH1wDPvtzWyUSNAXBGSk8h755YDbbcEy3SH2Q==",
+      "license": "MIT",
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/wooorm"
+      }
+    },
     "node_modules/stable-hash": {
       "version": "0.0.5",
       "resolved": "https://registry.npmjs.org/stable-hash/-/stable-hash-0.0.5.tgz",
@@ -8761,6 +10080,20 @@
         "url": "https://github.com/sponsors/ljharb"
       }
     },
+    "node_modules/stringify-entities": {
+      "version": "4.0.4",
+      "resolved": "https://registry.npmjs.org/stringify-entities/-/stringify-entities-4.0.4.tgz",
+      "integrity": "sha512-IwfBptatlO+QCJUo19AqvrPNqlVMpW9YEL2LIVY+Rpv2qsjCGxaDLNRgeGsQWJhfItebuJhsGSLjaBbNSQ+ieg==",
+      "license": "MIT",
+      "dependencies": {
+        "character-entities-html4": "^2.0.0",
+        "character-entities-legacy": "^3.0.0"
+      },
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/wooorm"
+      }
+    },
     "node_modules/strip-bom": {
       "version": "3.0.0",
       "resolved": "https://registry.npmjs.org/strip-bom/-/strip-bom-3.0.0.tgz",
@@ -8784,6 +10117,24 @@
         "url": "https://github.com/sponsors/sindresorhus"
       }
     },
+    "node_modules/style-to-js": {
+      "version": "1.1.21",
+      "resolved": "https://registry.npmjs.org/style-to-js/-/style-to-js-1.1.21.tgz",
+      "integrity": "sha512-RjQetxJrrUJLQPHbLku6U/ocGtzyjbJMP9lCNK7Ag0CNh690nSH8woqWH9u16nMjYBAok+i7JO1NP2pOy8IsPQ==",
+      "license": "MIT",
+      "dependencies": {
+        "style-to-object": "1.0.14"
+      }
+    },
+    "node_modules/style-to-object": {
+      "version": "1.0.14",
+      "resolved": "https://registry.npmjs.org/style-to-object/-/style-to-object-1.0.14.tgz",
+      "integrity": "sha512-LIN7rULI0jBscWQYaSswptyderlarFkjQ+t79nzty8tcIAceVomEVlLzH5VP4Cmsv6MtKhs7qaAiwlcp+Mgaxw==",
+      "license": "MIT",
+      "dependencies": {
+        "inline-style-parser": "0.2.7"
+      }
+    },
     "node_modules/styled-jsx": {
       "version": "5.1.6",
       "resolved": "https://registry.npmjs.org/styled-jsx/-/styled-jsx-5.1.6.tgz",
@@ -8955,6 +10306,26 @@
         "node": ">=8.0"
       }
     },
+    "node_modules/trim-lines": {
+      "version": "3.0.1",
+      "resolved": "https://registry.npmjs.org/trim-lines/-/trim-lines-3.0.1.tgz",
+      "integrity": "sha512-kRj8B+YHZCc9kQYdWfJB2/oUl9rA99qbowYYBtr4ui4mZyAQ2JpvVBd/6U2YloATfqBhBTSMhTpgBHtU0Mf3Rg==",
+      "license": "MIT",
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/wooorm"
+      }
+    },
+    "node_modules/trough": {
+      "version": "2.2.0",
+      "resolved": "https://registry.npmjs.org/trough/-/trough-2.2.0.tgz",
+      "integrity": "sha512-tmMpK00BjZiUyVyvrBK7knerNgmgvcV/KLVyuma/SC+TQN167GrMRciANTz09+k3zW8L8t60jWO1GpfkZdjTaw==",
+      "license": "MIT",
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/wooorm"
+      }
+    },
     "node_modules/ts-api-utils": {
       "version": "2.1.0",
       "resolved": "https://registry.npmjs.org/ts-api-utils/-/ts-api-utils-2.1.0.tgz",
@@ -9195,6 +10566,93 @@
         "node": ">=4"
       }
     },
+    "node_modules/unified": {
+      "version": "11.0.5",
+      "resolved": "https://registry.npmjs.org/unified/-/unified-11.0.5.tgz",
+      "integrity": "sha512-xKvGhPWw3k84Qjh8bI3ZeJjqnyadK+GEFtazSfZv/rKeTkTjOJho6mFqh2SM96iIcZokxiOpg78GazTSg8+KHA==",
+      "license": "MIT",
+      "dependencies": {
+        "@types/unist": "^3.0.0",
+        "bail": "^2.0.0",
+        "devlop": "^1.0.0",
+        "extend": "^3.0.0",
+        "is-plain-obj": "^4.0.0",
+        "trough": "^2.0.0",
+        "vfile": "^6.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/unist-util-is": {
+      "version": "6.0.1",
+      "resolved": "https://registry.npmjs.org/unist-util-is/-/unist-util-is-6.0.1.tgz",
+      "integrity": "sha512-LsiILbtBETkDz8I9p1dQ0uyRUWuaQzd/cuEeS1hoRSyW5E5XGmTzlwY1OrNzzakGowI9Dr/I8HVaw4hTtnxy8g==",
+      "license": "MIT",
+      "dependencies": {
+        "@types/unist": "^3.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/unist-util-position": {
+      "version": "5.0.0",
+      "resolved": "https://registry.npmjs.org/unist-util-position/-/unist-util-position-5.0.0.tgz",
+      "integrity": "sha512-fucsC7HjXvkB5R3kTCO7kUjRdrS0BJt3M/FPxmHMBOm8JQi2BsHAHFsy27E0EolP8rp0NzXsJ+jNPyDWvOJZPA==",
+      "license": "MIT",
+      "dependencies": {
+        "@types/unist": "^3.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/unist-util-stringify-position": {
+      "version": "4.0.0",
+      "resolved": "https://registry.npmjs.org/unist-util-stringify-position/-/unist-util-stringify-position-4.0.0.tgz",
+      "integrity": "sha512-0ASV06AAoKCDkS2+xw5RXJywruurpbC4JZSm7nr7MOt1ojAzvyyaO+UxZf18j8FCF6kmzCZKcAgN/yu2gm2XgQ==",
+      "license": "MIT",
+      "dependencies": {
+        "@types/unist": "^3.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/unist-util-visit": {
+      "version": "5.1.0",
+      "resolved": "https://registry.npmjs.org/unist-util-visit/-/unist-util-visit-5.1.0.tgz",
+      "integrity": "sha512-m+vIdyeCOpdr/QeQCu2EzxX/ohgS8KbnPDgFni4dQsfSCtpz8UqDyY5GjRru8PDKuYn7Fq19j1CQ+nJSsGKOzg==",
+      "license": "MIT",
+      "dependencies": {
+        "@types/unist": "^3.0.0",
+        "unist-util-is": "^6.0.0",
+        "unist-util-visit-parents": "^6.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/unist-util-visit-parents": {
+      "version": "6.0.2",
+      "resolved": "https://registry.npmjs.org/unist-util-visit-parents/-/unist-util-visit-parents-6.0.2.tgz",
+      "integrity": "sha512-goh1s1TBrqSqukSc8wrjwWhL0hiJxgA8m4kFxGlQ+8FYQ3C/m11FcTs4YYem7V664AhHVvgoQLk890Ssdsr2IQ==",
+      "license": "MIT",
+      "dependencies": {
+        "@types/unist": "^3.0.0",
+        "unist-util-is": "^6.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
     "node_modules/unrs-resolver": {
       "version": "1.11.1",
       "resolved": "https://registry.npmjs.org/unrs-resolver/-/unrs-resolver-1.11.1.tgz",
@@ -9313,6 +10771,34 @@
         }
       }
     },
+    "node_modules/vfile": {
+      "version": "6.0.3",
+      "resolved": "https://registry.npmjs.org/vfile/-/vfile-6.0.3.tgz",
+      "integrity": "sha512-KzIbH/9tXat2u30jf+smMwFCsno4wHVdNmzFyL+T/L3UGqqk6JKfVqOFOZEpZSHADH1k40ab6NUIXZq422ov3Q==",
+      "license": "MIT",
+      "dependencies": {
+        "@types/unist": "^3.0.0",
+        "vfile-message": "^4.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/vfile-message": {
+      "version": "4.0.3",
+      "resolved": "https://registry.npmjs.org/vfile-message/-/vfile-message-4.0.3.tgz",
+      "integrity": "sha512-QTHzsGd1EhbZs4AsQ20JX1rC3cOlt/IWJruk893DfLRr57lcnOeMaWG4K0JrRta4mIJZKth2Au3mM3u03/JWKw==",
+      "license": "MIT",
+      "dependencies": {
+        "@types/unist": "^3.0.0",
+        "unist-util-stringify-position": "^4.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
     "node_modules/which": {
       "version": "2.0.2",
       "resolved": "https://registry.npmjs.org/which/-/which-2.0.2.tgz",
@@ -9469,6 +10955,16 @@
       "peerDependencies": {
         "zod": "^3.25.0 || ^4.0.0"
       }
+    },
+    "node_modules/zwitch": {
+      "version": "2.0.4",
+      "resolved": "https://registry.npmjs.org/zwitch/-/zwitch-2.0.4.tgz",
+      "integrity": "sha512-bXE4cR/kVZhKZX/RjPEflHaKVhUVl85noU3v6b8apfQEc1x4A+zBxjZ4lN8LqGd6WZ3dl98pY4o717VFmoPp+A==",
+      "license": "MIT",
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/wooorm"
+      }
     }
   }
 }

frontend/package.json

@@ -22,7 +22,10 @@
     "react-dom": "^19.2.1",
     "react-dropzone": "^14.3.8",
     "react-icons": "^5.5.0",
+    "react-markdown": "^10.1.0",
     "react-use-measure": "^2.1.7",
+    "rehype-sanitize": "^6.0.0",
+    "remark-gfm": "^4.0.1",
     "tailwind-merge": "^3.3.1"
   },
   "devDependencies": {

ingest.py

@@ -100,7 +100,11 @@ def ingest_single_technique(
 
 
 def ingest_data():
-    """Load CBT book, chunk it 6 ways, and upload ALL to a SINGLE Pinecone index."""
+    """Load CBT book, chunk it 6 ways, and upload ALL to a SINGLE Pinecone index.
+    
+    Returns:
+        Tuple of (all_chunks, configured_technique_chunks, processor) for reuse in retrieval pipeline.
+    """
     load_dotenv()
 
     pinecone_key = os.getenv("PINECONE_API_KEY")
@@ -137,6 +141,7 @@ def ingest_data():
     print(f"{'='*80}")
 
     all_chunks = []
+    configured_technique_chunks = []
     results = {}
 
     for i, technique in enumerate(CHUNKING_TECHNIQUES, 1):
@@ -149,6 +154,11 @@ def ingest_data():
                 total_techniques=len(CHUNKING_TECHNIQUES),
             )
             all_chunks.extend(chunks)
+            
+            # Save chunks for the configured technique (for retrieval pipeline)
+            if technique["name"] == cfg.processing['technique']:
+                configured_technique_chunks = chunks
+            
             results[technique["name"]] = {
                 "status": "success",
                 "chunks": len(chunks),
@@ -215,6 +225,9 @@ def ingest_data():
 
     print("\nYou can now start the API server with:")
     print("  python -m uvicorn api:app --host 0.0.0.0 --port 8000")
+    
+    # Return chunks and processor for reuse in retrieval pipeline
+    return all_chunks, configured_technique_chunks, proc, index
 
 
 if __name__ == "__main__":

main.py

@@ -1,4 +1,7 @@
 import os
+import json
+import time
+from datetime import datetime
 from dotenv import load_dotenv
 from config_loader import cfg
 
@@ -8,6 +11,7 @@ from retriever.generator import RAGGenerator
 from retriever.processor import ChunkProcessor
 from retriever.evaluator import RAGEvaluator
 from data_loader import load_cbt_book, get_book_stats
+from ingest import ingest_data, CHUNKING_TECHNIQUES
 
 # Import model fleet
 from models.llama_3_8b import Llama3_8B
@@ -27,172 +31,440 @@ MODEL_MAP = {
 load_dotenv()
 
 
+def run_rag_for_technique(technique_name, query, index, encoder, models, evaluator, rag_engine):
+    """Run RAG pipeline for a specific chunking technique."""
+    
+    print(f"\n{'='*80}")
+    print(f"TECHNIQUE: {technique_name.upper()}")
+    print(f"{'='*80}")
+    
+    # Filter chunks by technique metadata
+    query_vector = encoder.encode(query).tolist()
+    
+    # Query with metadata filter for this technique - get more candidates for reranking
+    res = index.query(
+        vector=query_vector,
+        top_k=100,  # Get 100 candidates for reranking
+        include_metadata=True,
+        filter={"technique": {"$eq": technique_name}}
+    )
+    
+    # Extract context chunks
+    all_candidates = [match['metadata']['text'] for match in res['matches']]
+    
+    print(f"\nRetrieved {len(all_candidates)} candidate chunks for technique '{technique_name}'")
+    
+    if not all_candidates:
+        print(f"WARNING: No chunks found for technique '{technique_name}'")
+        return {}
+    
+    # Apply cross-encoder reranking to get top 5
+    # Don't create a temporary retriever with empty list (causes division by zero in BM25)
+    from sentence_transformers import CrossEncoder
+    rerank_model = CrossEncoder('cross-encoder/ms-marco-MiniLM-L-6-v2')
+    pairs = [[query, chunk] for chunk in all_candidates]
+    scores = rerank_model.predict(pairs)
+    ranked = sorted(zip(all_candidates, scores), key=lambda x: x[1], reverse=True)
+    context_chunks = [chunk for chunk, _ in ranked[:5]]
+    
+    print(f"After reranking: {len(context_chunks)} chunks (top 5)")
+    
+    # Print the final RAG context being passed to models
+    print(f"\n{'='*80}")
+    print(f"📚 FINAL RAG CONTEXT FOR TECHNIQUE '{technique_name.upper()}'")
+    print(f"{'='*80}")
+    for i, chunk in enumerate(context_chunks, 1):
+        print(f"\n[Chunk {i}] ({len(chunk)} chars):")
+        print(f"{'─'*60}")
+        print(chunk)
+        print(f"{'─'*60}")
+    print(f"\n{'='*80}")
+    
+    # Run model tournament for this technique
+    tournament_results = {}
+    
+    for name, model_inst in models.items():
+        print(f"\n{'-'*60}")
+        print(f"Model: {name}")
+        print(f"{'-'*60}")
+        try:
+            # Generation
+            answer = rag_engine.get_answer(
+                model_inst, query, context_chunks,
+                temperature=cfg.gen['temperature']
+            )
+
+            print(f"\n{'─'*60}")
+            print(f"📝 FULL ANSWER from {name}:")
+            print(f"{'─'*60}")
+            print(answer)
+            print(f"{'─'*60}")
+
+            # Faithfulness Evaluation (strict=False reduces API calls from ~22 to ~3 per eval)
+            faith = evaluator.evaluate_faithfulness(answer, context_chunks, strict=False)
+            # Relevancy Evaluation
+            rel = evaluator.evaluate_relevancy(query, answer)
+
+            tournament_results[name] = {
+                "answer": answer,
+                "Faithfulness": faith['score'],
+                "Relevancy": rel['score'],
+                "Claims": faith['details'],
+                "context_chunks": context_chunks
+            }
+
+            print(f"\n📊 EVALUATION SCORES:")
+            print(f"  Faithfulness: {faith['score']:.1f}%")
+            print(f"  Relevancy: {rel['score']:.3f}")
+            print(f"  Combined: {faith['score'] + rel['score']:.3f}")
+
+        except Exception as e:
+            print(f"  Error evaluating {name}: {e}")
+            tournament_results[name] = {
+                "answer": "",
+                "Faithfulness": 0,
+                "Relevancy": 0,
+                "Claims": [],
+                "error": str(e),
+                "context_chunks": context_chunks
+            }
+    
+    return tournament_results
+
+
+def generate_findings_document(all_results, query, output_file="rag_ablation_findings.md"):
+    """Generate detailed markdown document with findings from all techniques."""
+    
+    timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+    
+    content = f"""# RAG Ablation Study Findings
+
+**Generated:** {timestamp}
+
+## Overview
+
+This document presents findings from a comparative analysis of 6 different chunking techniques 
+applied to a Cognitive Behavioral Therapy (CBT) book. Each technique was evaluated using 
+multiple LLM models with RAG (Retrieval-Augmented Generation) pipeline.
+
+**Query:** {query}
+
+## Chunking Techniques Evaluated
+
+1. **Fixed** - Fixed-size chunking (1000 chars, 100 overlap)
+2. **Sentence** - Sentence-level chunking (NLTK)
+3. **Paragraph** - Paragraph-level chunking (\\n\\n boundaries)
+4. **Semantic** - Semantic chunking (embedding similarity)
+5. **Recursive** - Recursive chunking (hierarchical separators)
+6. **Page** - Page-level chunking (--- Page markers)
+
+## Results by Technique
+
+"""
+    
+    # Add results for each technique
+    for technique_name, model_results in all_results.items():
+        content += f"### {technique_name.upper()} Chunking\n\n"
+        
+        if not model_results:
+            content += "*No results available for this technique.*\n\n"
+            continue
+        
+        # Create results table
+        content += "| Model | Faithfulness | Relevancy | Combined Score |\n"
+        content += "|-------|--------------|-----------|----------------|\n"
+        
+        for model_name, results in model_results.items():
+            faith = results.get('Faithfulness', 0)
+            rel = results.get('Relevancy', 0)
+            combined = faith + rel
+            content += f"| {model_name} | {faith:.1f}% | {rel:.3f} | {combined:.3f} |\n"
+        
+        # Find best model for this technique
+        if model_results:
+            best_model = max(
+                model_results.items(),
+                key=lambda x: x[1].get('Faithfulness', 0) + x[1].get('Relevancy', 0)
+            )
+            best_name = best_model[0]
+            best_faith = best_model[1].get('Faithfulness', 0)
+            best_rel = best_model[1].get('Relevancy', 0)
+            
+            content += f"\n**Best Model:** {best_name} (Faithfulness: {best_faith:.1f}%, Relevancy: {best_rel:.3f})\n\n"
+        
+        # Add detailed RAG results for each model
+        content += "#### Detailed RAG Results\n\n"
+        
+        for model_name, results in model_results.items():
+            answer = results.get('answer', '')
+            context_chunks = results.get('context_chunks', [])
+            faith = results.get('Faithfulness', 0)
+            rel = results.get('Relevancy', 0)
+            
+            content += f"**{model_name}** (Faithfulness: {faith:.1f}%, Relevancy: {rel:.3f})\n\n"
+            
+            # Add answer
+            content += "📝 **Full Answer:**\n\n"
+            content += f"```\n{answer}\n```\n\n"
+            
+            # Add context chunks used
+            content += "📚 **Context Chunks Used:**\n\n"
+            for i, chunk in enumerate(context_chunks, 1):
+                content += f"**Chunk {i}:**\n"
+                content += f"```\n{chunk}\n```\n\n"
+            
+            content += "---\n\n"
+    
+    # Add comparative analysis
+    content += """## Comparative Analysis
+
+### Overall Performance Ranking
+
+| Rank | Technique | Avg Faithfulness | Avg Relevancy | Avg Combined |
+|------|-----------|------------------|---------------|--------------|
+"""
+    
+    # Calculate averages for each technique
+    technique_averages = {}
+    for technique_name, model_results in all_results.items():
+        if model_results:
+            avg_faith = sum(r.get('Faithfulness', 0) for r in model_results.values()) / len(model_results)
+            avg_rel = sum(r.get('Relevancy', 0) for r in model_results.values()) / len(model_results)
+            avg_combined = avg_faith + avg_rel
+            technique_averages[technique_name] = {
+                'faith': avg_faith,
+                'rel': avg_rel,
+                'combined': avg_combined
+            }
+    
+    # Sort by combined score
+    sorted_techniques = sorted(
+        technique_averages.items(),
+        key=lambda x: x[1]['combined'],
+        reverse=True
+    )
+    
+    for rank, (technique_name, averages) in enumerate(sorted_techniques, 1):
+        content += f"| {rank} | {technique_name} | {averages['faith']:.1f}% | {averages['rel']:.3f} | {averages['combined']:.3f} |\n"
+    
+    content += """
+### Key Findings
+
+"""
+    
+    if sorted_techniques:
+        best_technique = sorted_techniques[0][0]
+        worst_technique = sorted_techniques[-1][0]
+        
+        content += f"""
+1. **Best Performing Technique:** {best_technique}
+   - Achieved highest combined score across all models
+   - Recommended for production RAG applications
+
+2. **Worst Performing Technique:** {worst_technique}
+   - Lower combined scores across models
+   - May need optimization or different configuration
+
+3. **Model Consistency:** 
+   - Analyzed which models perform consistently across techniques
+   - Identified technique-specific model preferences
+
+"""
+    
+    content += """## Recommendations
+
+Based on the ablation study results:
+
+1. **Primary Recommendation:** Use the best-performing chunking technique for your specific use case
+2. **Hybrid Approach:** Consider combining techniques for different types of queries
+3. **Model Selection:** Choose models that perform well across multiple techniques
+4. **Parameter Tuning:** Optimize chunk sizes and overlaps based on document characteristics
+
+## Technical Details
+
+- **Embedding Model:** Jina embeddings (512 dimensions)
+- **Vector Database:** Pinecone (serverless, AWS us-east-1)
+- **Judge Model:** Openrouter Free models
+- **Retrieval:** Top 5 chunks per technique
+- **Evaluation Metrics:** Faithfulness (context grounding), Relevancy (query addressing)
+
+---
+
+*This report was automatically generated by the RAG Ablation Study Pipeline.*
+"""
+    
+    # Write to file
+    with open(output_file, 'w', encoding='utf-8') as f:
+        f.write(content)
+    
+    print(f"\nFindings document saved to: {output_file}")
+    return output_file
+
+
 def main():
-    """Main function to run the RAG tournament on CBT book."""
+    """Main function to run RAG ablation study across all 6 chunking techniques."""
     hf_token = os.getenv("HF_TOKEN")
     pinecone_key = os.getenv("PINECONE_API_KEY")
-    groq_key = os.getenv("GROQ_API_KEY")
+    openrouter_key = os.getenv("OPENROUTER_API_KEY")
 
     # Verify environment variables
     if not hf_token:
         raise RuntimeError("HF_TOKEN not found in environment variables")
     if not pinecone_key:
         raise RuntimeError("PINECONE_API_KEY not found in environment variables")
-    if not groq_key:
-        raise RuntimeError("GROQ_API_KEY not found in environment variables")
+    if not openrouter_key:
+        raise RuntimeError("OPENROUTER_API_KEY not found in environment variables")
 
-    # Example query for testing
+    # Test query
     query = "What is cognitive behavior therapy and how does it work?"
 
     print("=" * 80)
-    print("CBT RAG SYSTEM - LOADING DATA")
-    print("=" * 80)
-
-    # 1. Data Ingestion - Load CBT Book
-    raw_data = load_cbt_book("EntireBookCleaned.txt")
-    stats = get_book_stats(raw_data)
-    print(f"Book Statistics: {stats}")
-
-    print("\n" + "=" * 80)
-    print("CHUNKING AND EMBEDDING")
-    print("=" * 80)
-
-    # 2. Chunking & Embedding
-    proc = ChunkProcessor(model_name=cfg.processing['embedding_model'])
-    final_chunks = proc.process(
-        raw_data,
-        technique=cfg.processing['technique'],
-        chunk_size=cfg.processing['chunk_size'],
-        chunk_overlap=cfg.processing['chunk_overlap'],
-        max_docs=cfg.project.get('doc_limit'),  # None means load all
-        verbose=True
-    )
-
-    print(f"\nTotal chunks created: {len(final_chunks)}")
-
-    print("\n" + "=" * 80)
-    print("VECTOR DATABASE SETUP")
-    print("=" * 80)
-
-    # 3. Vector DB - Create/Update Pinecone Index
-    index = get_pinecone_index(
-        pinecone_key,
-        cfg.db['base_index_name'],
-        technique=cfg.processing['technique'],
-        dimension=cfg.db['dimension']
-    )
-    refresh_pinecone_index(index, final_chunks, batch_size=cfg.db['batch_size'])
-
-    print("\n" + "=" * 80)
-    print("RETRIEVAL SETUP")
+    print("RAG ABLATION STUDY - 6 CHUNKING TECHNIQUES")
     print("=" * 80)
 
-    # 4. Retrieval Setup
-    retriever = HybridRetriever(final_chunks, proc.encoder)
-
+    # Step 1: Check if data already exists, skip ingestion if so
     print("\n" + "=" * 80)
-    print(f"TESTING QUERY: {query}")
+    print("STEP 1: CHECKING/INGESTING DATA WITH ALL 6 TECHNIQUES")
     print("=" * 80)
 
-    # Test retrieval
-    context_chunks = retriever.search(
-        query, index,
-        mode=cfg.retrieval['mode'],
-        rerank_strategy=cfg.retrieval['rerank_strategy'],
-        use_mmr=cfg.retrieval['use_mmr'],
-        top_k=cfg.retrieval['top_k'],
-        final_k=cfg.retrieval['final_k']
-    )
-
-    print(f"\nRetrieved {len(context_chunks)} context chunks")
-
+    # Check if index already has data
+    pinecone_key = os.getenv("PINECONE_API_KEY")
+    from vector_db import get_index_by_name
+    index_name = f"{cfg.db['base_index_name']}-{cfg.processing['technique']}"
+    
+    print(f"\nChecking for existing index: {index_name}")
+    
+    try:
+        # Try to connect to existing index
+        print("Connecting to Pinecone...")
+        existing_index = get_index_by_name(pinecone_key, index_name)
+        print("Getting index stats...")
+        stats = existing_index.describe_index_stats()
+        existing_count = stats.get('total_vector_count', 0)
+        
+        if existing_count > 0:
+            print(f"\n✓ Found existing index with {existing_count} vectors")
+            print("Skipping ingestion - using existing data")
+            
+            # Initialize processor (this loads the embedding model)
+            print("Loading embedding model for retrieval...")
+            from retriever.processor import ChunkProcessor
+            proc = ChunkProcessor(model_name=cfg.processing['embedding_model'], verbose=False)
+            index = existing_index
+            all_chunks = []  # Empty since we're using existing data
+            final_chunks = []
+            print("✓ Processor initialized")
+        else:
+            print("\nIndex exists but is empty. Running full ingestion...")
+            all_chunks, final_chunks, proc, index = ingest_data()
+    except Exception as e:
+        print(f"\nIndex check failed: {e}")
+        print("Running full ingestion...")
+        all_chunks, final_chunks, proc, index = ingest_data()
+
+    print(f"\nTechniques to evaluate: {[tech['name'] for tech in CHUNKING_TECHNIQUES]}")
+
+    # Step 2: Initialize components
     print("\n" + "=" * 80)
-    print("MODEL TOURNAMENT")
+    print("STEP 2: INITIALIZING COMPONENTS")
     print("=" * 80)
 
-    # 5. Initialize Models
+    # Initialize models
+    print("\nInitializing models...")
     rag_engine = RAGGenerator()
     models = {name: MODEL_MAP[name](token=hf_token) for name in cfg.model_list}
 
-    # 6. Setup Evaluator with Judge
+    # Initialize evaluator
+    print("Initializing evaluator...")
+    openrouter_key = os.getenv("OPENROUTER_API_KEY")
+    if not openrouter_key:
+        raise RuntimeError("OPENROUTER_API_KEY not found in environment variables")
+    
     evaluator = RAGEvaluator(
         judge_model=cfg.gen['judge_model'],
         embedding_model=proc.encoder,
-        api_key=groq_key
+        api_key=openrouter_key
     )
 
-    tournament_results = {}
+    # Step 3: Run RAG for each technique
+    print("\n" + "=" * 80)
+    print("STEP 3: RUNNING RAG FOR ALL 6 TECHNIQUES")
+    print("=" * 80)
 
-    # 7. Tournament Loop
-    for name, model_inst in models.items():
-        print(f"\n{'='*60}")
-        print(f"Processing {name}")
-        print('='*60)
+    all_results = {}
+
+    for i, technique in enumerate(CHUNKING_TECHNIQUES, 1):
+        technique_name = technique['name']
+        
+        print(f"\n[{i}/{len(CHUNKING_TECHNIQUES)}] Processing technique: {technique_name}")
+        
         try:
-            # Generation
-            answer = rag_engine.get_answer(
-                model_inst, query, context_chunks,
-                temperature=cfg.gen['temperature']
+            results = run_rag_for_technique(
+                technique_name=technique_name,
+                query=query,
+                index=index,
+                encoder=proc.encoder,
+                models=models,
+                evaluator=evaluator,
+                rag_engine=rag_engine
             )
+            
+            all_results[technique_name] = results
+            
+            print(f"\n✓ Completed technique: {technique_name}")
+            
+        except Exception as e:
+            import traceback
+            print(f"\n✗ Error processing technique {technique_name}: {e}")
+            print(f"Full traceback:")
+            traceback.print_exc()
+            all_results[technique_name] = {}
 
-            print(f"\nAnswer from {name}:")
-            print(answer[:500] + "..." if len(answer) > 500 else answer)
-
-            # Faithfulness Evaluation
-            faith = evaluator.evaluate_faithfulness(answer, context_chunks)
-            # Relevancy Evaluation
-            rel = evaluator.evaluate_relevancy(query, answer)
-
-            tournament_results[name] = {
-                "answer": answer,
-                "Faithfulness": faith['score'],
-                "Relevancy": rel['score'],
-                "Claims": faith['details']
-            }
-
-            print(f"\n{name} Results:")
-            print(f"  Faithfulness: {faith['score']:.1f}%")
-            print(f"  Relevancy: {rel['score']:.3f}")
+    # Step 4: Generate findings document
+    print("\n" + "=" * 80)
+    print("STEP 4: GENERATING FINDINGS DOCUMENT")
+    print("=" * 80)
 
-        except Exception as e:
-            print(f"Error evaluating {name}: {e}")
-            tournament_results[name] = {
-                "answer": "",
-                "Faithfulness": 0,
-                "Relevancy": 0,
-                "Claims": [],
-                "error": str(e)
-            }
+    findings_file = generate_findings_document(all_results, query)
 
-    # 8. Final Results Summary
+    # Step 5: Final summary
     print("\n" + "=" * 80)
-    print("TOURNAMENT RESULTS SUMMARY")
+    print("ABLATION STUDY COMPLETE - SUMMARY")
     print("=" * 80)
 
     print(f"\nQuery: {query}")
-    print(f"\nRetrieved Context Chunks: {len(context_chunks)}")
+    print(f"Techniques evaluated: {len(CHUNKING_TECHNIQUES)}")
+    print(f"Models tested: {len(cfg.model_list)}")
+    print(f"\nFindings document: {findings_file}")
+
+    # Print quick summary
     print("\n" + "-" * 60)
-    print(f"{'Model':<20} {'Faithfulness':>15} {'Relevancy':>15}")
+    print(f"{'Technique':<15} {'Avg Faith':>12} {'Avg Rel':>12} {'Best Model':<20}")
     print("-" * 60)
 
-    for name, results in tournament_results.items():
-        faith = results.get('Faithfulness', 0)
-        rel = results.get('Relevancy', 0)
-        print(f"{name:<20} {faith:>14.1f}% {rel:>15.3f}")
+    for technique_name, model_results in all_results.items():
+        if model_results:
+            avg_faith = sum(r.get('Faithfulness', 0) for r in model_results.values()) / len(model_results)
+            avg_rel = sum(r.get('Relevancy', 0) for r in model_results.values()) / len(model_results)
+            
+            # Find best model
+            best_model = max(
+                model_results.items(),
+                key=lambda x: x[1].get('Faithfulness', 0) + x[1].get('Relevancy', 0)
+            )
+            best_name = best_model[0]
+            
+            print(f"{technique_name:<15} {avg_faith:>11.1f}% {avg_rel:>12.3f} {best_name:<20}")
+        else:
+            print(f"{technique_name:<15} {'N/A':>12} {'N/A':>12} {'N/A':<20}")
 
     print("-" * 60)
 
-    # Find best model
-    if tournament_results:
-        best_model = max(
-            tournament_results.items(),
-            key=lambda x: x[1].get('Faithfulness', 0) + x[1].get('Relevancy', 0)
-        )
-        print(f"\nBest Overall Model: {best_model[0]}")
-        print(f"  Faithfulness: {best_model[1]['Faithfulness']:.1f}%")
-        print(f"  Relevancy: {best_model[1]['Relevancy']:.3f}")
+    print("\n✓ Ablation study complete!")
+    print(f"✓ Results saved to: {findings_file}")
+    print("\nYou can now analyze the findings document to compare chunking techniques.")
 
-    return tournament_results
+    return all_results
 
 
 if __name__ == "__main__":

models/deepseek_v3.py

@@ -5,7 +5,7 @@ class DeepSeek_V3:
         self.client = InferenceClient(token=token)
         self.model_id = "deepseek-ai/DeepSeek-V3"
 
-    def generate(self, prompt, max_tokens=500, temperature=0.1):
+    def generate(self, prompt, max_tokens=1500, temperature=0.1):
         response = ""
         try:
             for message in self.client.chat_completion(

models/llama_3_8b.py

@@ -5,7 +5,7 @@ class Llama3_8B:
         self.client = InferenceClient(token=token)
         self.model_id = "meta-llama/Meta-Llama-3-8B-Instruct"
 
-    def generate(self, prompt, max_tokens=500, temperature=0.1):
+    def generate(self, prompt, max_tokens=1500, temperature=0.1):
         response = ""
         for message in self.client.chat_completion(
             model=self.model_id,

models/mistral_7b.py

@@ -5,7 +5,7 @@ class Mistral_7b:
         self.client = InferenceClient(api_key=token)
         self.model_id = "mistralai/Mistral-7B-Instruct-v0.2:featherless-ai"
 
-    def generate(self, prompt, max_tokens=500, temperature=0.1):
+    def generate(self, prompt, max_tokens=1500, temperature=0.1):
         response = ""
         try:
             stream = self.client.chat.completions.create(

models/qwen_2_5.py

@@ -5,7 +5,7 @@ class Qwen2_5:
         self.client = InferenceClient(token=token)
         self.model_id = "Qwen/Qwen2.5-72B-Instruct"
 
-    def generate(self, prompt, max_tokens=500, temperature=0.1):
+    def generate(self, prompt, max_tokens=1500, temperature=0.1):
         response = ""
         for message in self.client.chat_completion(
             model=self.model_id,

models/tiny_aya.py

@@ -5,7 +5,7 @@ class TinyAya:
         self.client = InferenceClient(token=token)
         self.model_id = "CohereLabs/tiny-aya-global"
 
-    def generate(self, prompt, max_tokens=500, temperature=0.1):
+    def generate(self, prompt, max_tokens=1500, temperature=0.1):
 
         response = ""
         try:

requirements.txt

@@ -93,3 +93,5 @@ xxhash==3.6.0
 yarl==1.23.0
 zstandard==0.25.0
 groq==0.13.0
+jiter==0.13.0
+openai==2.30.0

retriever/evaluator.py

@@ -1,37 +1,68 @@
 import re
 import numpy as np
 from sklearn.metrics.pairwise import cosine_similarity
-from groq import Groq
+from openai import OpenAI
+from concurrent.futures import ThreadPoolExecutor, as_completed
 
 
 # ------------------------------------------------------------------
-# Groq Judge Wrapper
+# OpenRouter Judge Wrapper
 # ------------------------------------------------------------------
 
 class GroqJudge:
-    def __init__(self, api_key: str, model: str = "llama-3.1-8b-instant"):
+    def __init__(self, api_key: str, model: str =   "qwen/qwen3.6-plus-preview:free",):
         """
-        Wraps Groq's chat completions to match the .generate(prompt) interface
+        Wraps OpenRouter's chat completions to match the .generate(prompt) interface
         expected by RAGEvaluator.
 
         Args:
-            api_key: Your Groq API key (https://console.groq.com)
-            model:   Groq model to use. Free tier options:
-                     - "llama-3.1-8b-instant"  (fastest)
-                     - "llama-3.3-70b-versatile" (more capable, slower)
-                     - "gemma2-9b-it"
+            api_key: Your OpenRouter API key (https://openrouter.ai)
+            model:   OpenRouter model to use (primary model with fallback support)
         """
-        self.client = Groq(api_key=api_key)
+        self.client = OpenAI(
+            base_url="https://openrouter.ai/api/v1",
+            api_key=api_key,
+        )
         self.model = model
+        
+        # Fallback models in order of preference (OpenRouter free models)
+        self.fallback_models = [
+            "qwen/qwen3.6-plus-preview:free",
+            "stepfun/step-3.5-flash:free",
+            "nvidia/nemotron-3-super-120b-a12b:free",
+            "z-ai/glm-4.5-air:free",
+            "nvidia/nemotron-3-nano-30b-a3b:free",
+            "arcee-ai/trinity-mini:free"
+        ]
 
     def generate(self, prompt: str) -> str:
-        response = self.client.chat.completions.create(
-            model=self.model,
-            messages=[{"role": "user", "content": prompt}],
-            temperature=0.0,   # deterministic for evaluation
-            max_tokens=1024,
-        )
-        return response.choices[0].message.content.strip()
+        """Generate response with fallback support for multiple models."""
+        last_error = None
+        
+        # Try primary model first, then fallbacks
+        models_to_try = [self.model] + [m for m in self.fallback_models if m != self.model]
+        
+        for model_name in models_to_try:
+            try:
+                response = self.client.chat.completions.create(
+                    model=model_name,
+                    messages=[{"role": "user", "content": prompt}],
+ 
+                )
+                content = response.choices[0].message.content
+                if content is None:
+                    raise ValueError(f"Model {model_name} returned None content")
+                return content.strip()
+            except Exception as e:
+                last_error = e
+                # If rate limited or model unavailable, try next model
+                if "429" in str(e) or "rate_limit" in str(e).lower() or "model" in str(e).lower():
+                    continue
+                # For other errors, raise immediately
+                raise
+        
+        # If all models fail, raise the last error
+        raise last_error
 
 
 # ------------------------------------------------------------------
@@ -41,10 +72,10 @@ class GroqJudge:
 class RAGEvaluator:
     def __init__(self, judge_model: str, embedding_model, api_key: str, verbose=True):
         """
-        judge_model:     Model name string passed to GroqJudge, must match cfg.gen['judge_model']
-                         e.g. "llama-3.1-8b-instant", "llama-3.3-70b-versatile", "gemma2-9b-it"
+        judge_model:     Model name string passed to OpenRouterJudge, must match cfg.gen['judge_model']
+                         e.g. "stepfun/step-3.5-flash:free", "nvidia/nemotron-3-super-120b-a12b:free"
         embedding_model: The proc.encoder (SentenceTransformer) for similarity checks
-        api_key:         Groq API key (https://console.groq.com)
+        api_key:         OpenRouter API key (https://openrouter.ai)
         verbose:         If True, prints progress via internal helpers
         """
         self.judge = GroqJudge(api_key=api_key, model=judge_model)
@@ -91,8 +122,14 @@ class RAGEvaluator:
         # --- Step B: Verification ---
         if strict:
             # Per-chunk: claim must be explicitly supported by at least one chunk
-            verdicts = {i: self._verify_claim_against_chunks(claim, context_list)
-                        for i, claim in enumerate(claims)}
+            # Parallelize across claims as well
+            def verify_claim_wrapper(args):
+                i, claim = args
+                return i, self._verify_claim_against_chunks(claim, context_list)
+            
+            with ThreadPoolExecutor(max_workers=min(len(claims), 5)) as executor:
+                futures = [executor.submit(verify_claim_wrapper, (i, claim)) for i, claim in enumerate(claims)]
+                verdicts = {i: result for future in as_completed(futures) for i, result in [future.result()]}
         else:
             # Batch: all chunks joined, strict burden-of-proof prompt
             combined_context = "\n".join(context_list)
@@ -140,7 +177,7 @@ class RAGEvaluator:
 
     def _verify_claim_against_chunks(self, claim: str, context_list: list[str]) -> bool:
         """Verify a single claim against each chunk individually. Returns True if any chunk supports it."""
-        for chunk in context_list:
+        def verify_single_chunk(chunk):
             prompt = (
                 f"Context:\n{chunk}\n\n"
                 f"Claim: {claim}\n\n"
@@ -148,8 +185,14 @@ class RAGEvaluator:
                 f"Do not infer or assume. Respond with YES or NO only."
             )
             result = self.judge.generate(prompt)
-            if "YES" in result.upper():
-                return True
+            return "YES" in result.upper()
+        
+        # Use ThreadPoolExecutor for parallel verification
+        with ThreadPoolExecutor(max_workers=min(len(context_list), 5)) as executor:
+            futures = [executor.submit(verify_single_chunk, chunk) for chunk in context_list]
+            for future in as_completed(futures):
+                if future.result():
+                    return True
         return False
 
     # ------------------------------------------------------------------

retriever/retriever.py

@@ -1,20 +1,40 @@
 import numpy as np
 import time
+import re
 from rank_bm25 import BM25Okapi
-from sentence_transformers import CrossEncoder
 from sklearn.metrics.pairwise import cosine_similarity
 from typing import Optional, List
 
+# Try to import FlashRank for CPU optimization, fallback to sentence-transformers
+try:
+    from flashrank import Ranker, RerankRequest
+    FLASHRANK_AVAILABLE = True
+except ImportError:
+    from sentence_transformers import CrossEncoder
+    FLASHRANK_AVAILABLE = False
+
 class HybridRetriever:
-    def __init__(self, final_chunks, embed_model, rerank_model_name='cross-encoder/ms-marco-MiniLM-L-6-v2', verbose: bool = True):
+    def __init__(self, final_chunks, embed_model, rerank_model_name='ms-marco-MiniLM-L-6-v2', verbose: bool = True):
         self.final_chunks = final_chunks
         self.embed_model = embed_model
-        self.rerank_model = CrossEncoder(rerank_model_name)
         self.verbose = verbose
         
-        self.tokenized_corpus = [chunk['metadata']['text'].lower().split() for chunk in final_chunks]
+        # Use FlashRank if available (faster on CPU), otherwise fallback to sentence-transformers
+        if FLASHRANK_AVAILABLE:
+            self.rerank_model = Ranker(model_name=rerank_model_name)
+            self.use_flashrank = True
+        else:
+            self.rerank_model = CrossEncoder(f'cross-encoder/{rerank_model_name}')
+            self.use_flashrank = False
+        
+        # Better tokenization for BM25 (strips punctuation)
+        self.tokenized_corpus = [self._tokenize(chunk['metadata']['text']) for chunk in final_chunks]
         self.bm25 = BM25Okapi(self.tokenized_corpus)
 
+    def _tokenize(self, text: str) -> List[str]:
+        """Tokenize text using regex to strip punctuation."""
+        return re.findall(r'\w+', text.lower())
+
     # ------------------------------------------------------------------
     # Retrieval
     # ------------------------------------------------------------------
@@ -26,7 +46,7 @@ class HybridRetriever:
         return query_vector, chunks
 
     def _bm25_search(self, query, top_k) -> List[str]:
-        tokenized_query = query.lower().split()
+        tokenized_query = self._tokenize(query)
         scores = self.bm25.get_scores(tokenized_query)
         top_indices = np.argsort(scores)[::-1][:top_k]
         return [self.final_chunks[i]['metadata']['text'] for i in top_indices]
@@ -48,42 +68,126 @@ class HybridRetriever:
     # ------------------------------------------------------------------
 
     def _cross_encoder_rerank(self, query, chunks, final_k) -> List[str]:
-        pairs = [[query, chunk] for chunk in chunks]
-        scores = self.rerank_model.predict(pairs)
-        ranked = sorted(zip(chunks, scores), key=lambda x: x[1], reverse=True)
-        return [chunk for chunk, _ in ranked[:final_k]]
+        if self.use_flashrank:
+            # Use FlashRank for CPU-optimized reranking
+            passages = [{"id": i, "text": chunk} for i, chunk in enumerate(chunks)]
+            rerank_request = RerankRequest(query=query, passages=passages)
+            results = self.rerank_model.rerank(rerank_request)
+            ranked_chunks = [res['text'] for res in results]
+            return ranked_chunks[:final_k]
+        else:
+            # Fallback to sentence-transformers CrossEncoder
+            pairs = [[query, chunk] for chunk in chunks]
+            scores = self.rerank_model.predict(pairs)
+            ranked = sorted(zip(chunks, scores), key=lambda x: x[1], reverse=True)
+            return [chunk for chunk, _ in ranked[:final_k]]
 
     # ------------------------------------------------------------------
     # MMR (applied after reranking as a diversity filter)
     # ------------------------------------------------------------------
 
     def _maximal_marginal_relevance(self, query_vector, chunks, lambda_param=0.5, top_k=3) -> List[str]:
+        """
+        Maximum Marginal Relevance (MMR) for diversity filtering.
+        
+        DIVISION BY ZERO DEBUGGING:
+        - This method can cause division by zero in cosine_similarity if vectors are zero
+        - We've added multiple safeguards to prevent this
+        """
+        print(f"    [MMR DEBUG] Starting MMR with {len(chunks)} chunks, top_k={top_k}")
+        
         if not chunks:
+            print(f"    [MMR DEBUG] No chunks, returning empty list")
             return []
         
-        chunk_embeddings = self.embed_model.encode(chunks)
+        # STEP 1: Encode chunks to get embeddings
+        print(f"    [MMR DEBUG] Encoding {len(chunks)} chunks...")
+        try:
+            chunk_embeddings = self.embed_model.encode(chunks)
+            print(f"    [MMR DEBUG] Chunk embeddings shape: {chunk_embeddings.shape}")
+        except Exception as e:
+            print(f"    [MMR DEBUG] ERROR encoding chunks: {e}")
+            return chunks[:top_k]
+        
+        # STEP 2: Reshape query vector
         query_embedding = query_vector.reshape(1, -1)
-        relevance_scores = cosine_similarity(query_embedding, chunk_embeddings)[0]
+        print(f"    [MMR DEBUG] Query embedding shape: {query_embedding.shape}")
+        
+        # STEP 3: Check for zero vectors (POTENTIAL DIVISION BY ZERO SOURCE)
+        print(f"    [MMR DEBUG] Checking for zero vectors...")
+        query_norm = np.linalg.norm(query_embedding)
+        chunk_norms = np.linalg.norm(chunk_embeddings, axis=1)
+        
+        print(f"    [MMR DEBUG] Query norm: {query_norm}")
+        print(f"    [MMR DEBUG] Chunk norms min: {chunk_norms.min()}, max: {chunk_norms.max()}")
+        
+        # Check for zero or near-zero vectors
+        if query_norm < 1e-10 or np.any(chunk_norms < 1e-10):
+            print(f"    [MMR DEBUG] WARNING: Zero or near-zero vectors detected!")
+            print(f"    [MMR DEBUG] Query norm < 1e-10: {query_norm < 1e-10}")
+            print(f"    [MMR DEBUG] Any chunk norm < 1e-10: {np.any(chunk_norms < 1e-10)}")
+            print(f"    [MMR DEBUG] Falling back to simple selection without MMR")
+            return chunks[:top_k]
+        
+        # STEP 4: Compute relevance scores (POTENTIAL DIVISION BY ZERO SOURCE)
+        print(f"    [MMR DEBUG] Computing relevance scores with cosine_similarity...")
+        try:
+            relevance_scores = cosine_similarity(query_embedding, chunk_embeddings)[0]
+            print(f"    [MMR DEBUG] Relevance scores computed successfully")
+            print(f"    [MMR DEBUG] Relevance scores shape: {relevance_scores.shape}")
+            print(f"    [MMR DEBUG] Relevance scores min: {relevance_scores.min()}, max: {relevance_scores.max()}")
+        except Exception as e:
+            print(f"    [MMR DEBUG] ERROR computing relevance scores: {e}")
+            print(f"    [MMR DEBUG] Falling back to simple selection")
+            return chunks[:top_k]
         
+        # STEP 5: Initialize selection
         selected, unselected = [], list(range(len(chunks)))
         
         first = int(np.argmax(relevance_scores))
         selected.append(first)
         unselected.remove(first)
+        print(f"    [MMR DEBUG] Selected first chunk: index {first}")
         
+        # STEP 6: Iteratively select chunks using MMR
+        print(f"    [MMR DEBUG] Starting MMR iteration...")
+        iteration = 0
         while len(selected) < min(top_k, len(chunks)):
-            mmr_scores = [
-                (i, lambda_param * relevance_scores[i] - (1 - lambda_param) * max(
-                    cosine_similarity(chunk_embeddings[i].reshape(1, -1),
-                                      chunk_embeddings[s].reshape(1, -1))[0][0]
-                    for s in selected
-                ))
-                for i in unselected
-            ]
-            best = max(mmr_scores, key=lambda x: x[1])[0]
-            selected.append(best)
-            unselected.remove(best)
+            iteration += 1
+            print(f"    [MMR DEBUG] Iteration {iteration}: selected={len(selected)}, unselected={len(unselected)}")
+            
+            # Calculate MMR scores
+            mmr_scores = []
+            for i in unselected:
+                # Compute max similarity to already selected items
+                max_sim = -1
+                for s in selected:
+                    try:
+                        # POTENTIAL DIVISION BY ZERO SOURCE: cosine_similarity
+                        sim = cosine_similarity(
+                            chunk_embeddings[i].reshape(1, -1),
+                            chunk_embeddings[s].reshape(1, -1)
+                        )[0][0]
+                        max_sim = max(max_sim, sim)
+                    except Exception as e:
+                        print(f"    [MMR DEBUG] ERROR computing similarity between chunk {i} and {s}: {e}")
+                        # If similarity computation fails, use 0
+                        max_sim = max(max_sim, 0)
+                
+                mmr_score = lambda_param * relevance_scores[i] - (1 - lambda_param) * max_sim
+                mmr_scores.append((i, mmr_score))
+            
+            # Select chunk with highest MMR score
+            if mmr_scores:
+                best = max(mmr_scores, key=lambda x: x[1])[0]
+                selected.append(best)
+                unselected.remove(best)
+                print(f"    [MMR DEBUG] Selected chunk {best} with MMR score {mmr_scores[best][1]:.4f}")
+            else:
+                print(f"    [MMR DEBUG] No MMR scores computed, breaking")
+                break
         
+        print(f"    [MMR DEBUG] MMR complete. Selected {len(selected)} chunks")
         return [chunks[i] for i in selected]
 
     # ------------------------------------------------------------------

test_backend.py

@@ -117,12 +117,12 @@ def test_evaluator():
     
     from retriever.evaluator import GroqJudge
     
-    groq_key = os.getenv("GROQ_API_KEY")
-    if not groq_key:
-        print("⚠ GROQ_API_KEY not set, skipping evaluator test")
+    openrouter_key = os.getenv("OPENROUTER_API_KEY")
+    if not openrouter_key:
+        print("⚠ OPENROUTER_API_KEY not set, skipping evaluator test")
         return None
     
-    judge = GroqJudge(api_key=groq_key, model="llama-3.1-8b-instant")
+    judge = GroqJudge(api_key=openrouter_key, model="stepfun/step-3.5-flash:free")
     
     # Simple test prompt
     test_prompt = "What is 2 + 2? Answer with just the number."

vector_db.py

@@ -98,7 +98,8 @@ def prepare_vectors_for_upsert(final_chunks):
                 'title': meta.get('title', ""),
                 'url': meta.get('url', ""),
                 'chunk_index': meta.get('chunk_index', 0),
-                'technique': meta.get('technique', "unknown")
+                'technique': meta.get('technique', "unknown"),
+                'chunking_technique': meta.get('chunking_technique', "unknown")
             }
         })
     return vectors