आर्किटेक्चर (वाइब कोडर गाइड)

1. पार्सिंग

विभिन्न सोर्स से कंटेंट को प्लेन टेक्स्ट में पार्स किया जाता है:

• Notion: हायरार्की बनाए रखते हुए ब्लॉक-बाय-ब्लॉक पार्सिंग
• DOCX: mammoth.js के ज़रिए एक्सट्रैक्ट
• Markdown: remark/unified से पार्स
• Website: वेबसाइट: क्रॉल और नेविगेशन/फ़ुटर से साफ़

2. चंकिंग

बेहतर रिट्रीवल के लिए टेक्स्ट को ओवरलैपिंग चंक में विभाजित किया जाता है:

{
  targetSize: 400,    // tokens per chunk
  overlap: 50,        // token overlap between chunks
  preserveHeadings: true,  // keep heading context
  minChunkSize: 100   // minimum viable chunk
}

हर चंक कॉन्टेक्स्ट के लिए अपनी पैरेंट हेडिंग हायरार्की बनाए रखता है।

3. एम्बेडिंग

चंक को 1536-डायमेंशनल वेक्टर में बदला जाता है:

Model: text-embedding-3-small
Dimensions: 1536
Provider: OpenAI (via OpenRouter)

4. स्टोरेज

वेक्टर pgvector एक्सटेंशन के साथ PostgreSQL में स्टोर किए जाते हैं:

-- content_chunks table
id: uuid
knowledge_base_id: uuid
page_id: string
page_title: string
content: text
embedding: vector(1536)
parent_heading: string

हाइब्रिड सर्च

हम दो-चरणीय रिट्रीवल प्रक्रिया का उपयोग करते हैं:

1. Vector Search: वेक्टर सर्च: pgvector के <=> ऑपरेटर का उपयोग करके कोसाइन सिमिलैरिटी
2. Keyword Fallback: कीवर्ड फ़ॉलबैक: अगर वेक्टर रिज़ल्ट्स में कम सिमिलैरिटी है, तो हम कीवर्ड-मैच्ड चंक जोड़ते हैं

सिमिलैरिटी स्कोरिंग

-- Vector similarity query
SELECT *, 1 - (embedding <=> query_embedding) as similarity
FROM content_chunks
WHERE knowledge_base_id = $1
ORDER BY embedding <=> query_embedding
LIMIT 5

कॉन्फ़िडेंस स्कोरिंग

जनरेट करने से पहले, हम कॉन्फ़िडेंस स्कोर कैलकुलेट करते हैं:

confidence = bestSimilarity + (hasMultipleChunks ? 0.1 : 0) + 0.2
// Capped at 1.0

if (confidence < threshold) {
  return refusalMessage;  // Don't hallucinate
}

उद्धरण एक्सट्रैक्शन

LLM को [Source N] फ़ॉर्मेट इस्तेमाल करने का निर्देश दिया जाता है। हम इन्हें पार्स करके मूल पेज से लिंक करते हैं:

// Extract citations from answer
const citationPattern = /\[Source (\d+)\]/g;
const matches = answer.matchAll(citationPattern);

// Map to original pages
citations = matches.map(m => chunks[m[1] - 1])