RAG — chunking, retrieval, reranking আর উত্তর তৈরি

এই পর্বের desktop run: Python 3.12, torch 2.15.0, transformers 5.22.2, sentence-transformers 6.2.0, লেখার সময়ে। Model তিনটি, সবই token ছাড়া নামানো যায়: embedding-এ intfloat/multilingual-e5-small (MIT), reranking-এ BAAI/bge-reranker-v2-m3 (Apache 2.0), উত্তর লিখতে Qwen/Qwen2.5-1.5B-Instruct (Apache 2.0). ডেটা বাজারঘরের ৪০টি হাতে লেখা help-centre নথি (ফেরত, রিফান্ড, জেলাভেদে ডেলিভারি চার্জ, পেমেন্ট, COD, ওয়ারেন্টি; বেশিরভাগ বাংলা, কিছু ইংরেজি আর Banglish) আর ৪১টি হাতে লেখা প্রশ্ন, সঠিক উত্তর আর সঠিক নথিসহ। সব নিয়ম আর সংখ্যা সম্পূর্ণ কাল্পনিক, কোনো আসল দোকানের নয়। সব ফল একটি স্থানীয় run-এর, ছোট model-এর; বড় বা hosted model-এ সংখ্যা আলাদা হবে। Vector আর similarity-র মূল কথা AI-এর ভিত্তি কোর্সের পর্ব ৩৩-এ, প্রথম vector search সেই কোর্সের পর্ব ৬৯-এ। Sentence embedding আর index-এর গভীর আলোচনা পর্ব ৬৭ · Sentence embedding আর semantic search ও পর্ব ৬৮ · Vector index-এ; এখানে সেগুলো ব্যবহার করে পুরো উত্তর-যন্ত্রটি জোড়া হবে।

১ · কেন RAG — বন্ধ বই বনাম খোলা বইয়ের পরীক্ষা

পর্ব ৫২-এ দেখেছেন, LLM-এর জ্ঞান training-এর তারিখে থেমে থাকে (knowledge cutoff), আর না জানলেও আত্মবিশ্বাসী ভঙ্গিতে লিখতে পারে (hallucination). বাজারঘরের সমস্যা আরও সরল: “গাজীপুরে ডেলিভারি চার্জ কত?” প্রশ্নের উত্তর পৃথিবীর কোনো training ডেটায় নেই, কারণ এটি একটি দোকানের নিজস্ব নিয়ম, আর নিয়ম বদলায়।

Retrieval-augmented generation (RAG) নামটি Lewis ও সহকর্মীদের ২০২০ সালের প্রবন্ধ থেকে। তাঁদের model-এ retriever আর generator একসঙ্গে শেখানো হয়েছিল; আজ “RAG” বলতে সাধারণত সরলতর রূপটি বোঝায়: আলাদা একটি retrieval ধাপ প্রশ্নের সঙ্গে মেলা নথির টুকরো আনে, সেগুলো prompt-এ বসে, আর model সেগুলো পড়ে উত্তর লেখে। নিয়ম বদলালে model নতুন করে শেখাতে হয় না, শুধু index হালনাগাদ। তবে RAG hallucination শূন্য করে না: ভুল টুকরো এলে, বা model টুকরো ঠিকমতো না পড়লে, ভুল উত্তর আসবেই। §৬-এ দেখবেন কতটা।

২ · Ingest আর chunking — নথিকে টুকরো করা

প্রথম ধাপ ingest: PDF, ওয়েবপাতা বা ডেটাবেস থেকে লেখা তোলা, পরিষ্কার করা (ফাঁকা লাইন, পাতার নম্বর, মেনুর লেখা বাদ), আর Unicode এক রূপে আনা (NFC, পর্ব ৪০)। তারপর chunking: নথিকে ছোট টুকরোয় ভাগ। কেন পুরো নথি নয়? তিনটি কারণ। এক, একটি embedding vector পুরো লেখার গড় অর্থ বহন করে; দশটি বিষয়ের নথির vector কোনো একটির সঙ্গেই ভালো মেলে না। দুই, prompt-এর জায়গা সীমিত (context window), আর প্রতিটি token-এর দাম আছে (পর্ব ৬৫)। তিন, ছোট টুকরো হলে citation-ও নির্দিষ্ট হয়।

Overlap মানে পাশাপাশি দুই টুকরোয় কিছু লেখা একই থাকা, যাতে সীমানায় কাটা পড়া তথ্য অন্তত একটি টুকরোয় পুরো থাকে। খরচ হলো বাড়তি জায়গা। Fixed size-এ মোট দৈর্ঘ্য L, টুকরো s, overlap o হলে টুকরো লাগে

n = ⌈(L − o) ÷ (s − o)⌉

কারণ প্রতিটি নতুন টুকরো (s − o) এগোয়, আর শেষ টুকরোর শুরু থেকে L পর্যন্ত s-এর মধ্যে আঁটতে হয়। L = ১,০০০, s = ২০০, o = ৫০ হলে n = ⌈৯৫০ ÷ ১৫০⌉ = ⌈৬.৩৩⌉ = ৭. ⌈ ⌉ মানে ওপরের দিকে পূর্ণসংখ্যা।

নিচের কোড ঠিক এই নিয়ম চালায়, আর শেষে fixed size-এর সূত্রটি মিলিয়ে দেখায়।

import re, math
DOC = """## ইলেকট্রনিক্স
ইলেকট্রনিক্স পণ্য ৭ দিনের মধ্যে শুধু ত্রুটি থাকলে ফেরত বা বদল হয়। বাক্সের সিল খোলা হলে মন বদলের কারণে ফেরত নেওয়া হয় না। ভাঙা পণ্য পেলে ৪৮ ঘণ্টার মধ্যে ছবিসহ জানাতে হয়। প্যাকেট খোলার ভিডিও রাখলে দাবি দ্রুত নিষ্পত্তি হয়।
## যাচাই
ফেরত আসা পণ্য গুদামে পরীক্ষার পর ২ কর্মদিবসের মধ্যে SMS যায়।"""

def sentences(text):                       # দাঁড়ি, ? ! আর . -এর পরে ভাঙা
    return [s for s in re.split(r"(?<=[।?!.])\s+", text.strip()) if s]

def chunk(doc, max_words=24, overlap=1):
    out = []
    for part in re.split(r"^## ", doc, flags=re.M)[1:]:
        head, body = part.split("\n", 1)
        sents, i = sentences(body), 0
        while i < len(sents):
            j, w = i, 0
            while j < len(sents) and (j == i or w + len(sents[j].split()) <= max_words):
                w += len(sents[j].split()); j += 1
            out.append((head, i, j, w, " ".join(sents[i:j])))
            if j >= len(sents): break
            i = max(j - overlap, i + 1)     # শেষের overlap-টি বাক্য আবার নিয়ে শুরু
    return out

for n, (head, i, j, w, text) in enumerate(chunk(DOC)):
    print(f"#{n} [{head}] বাক্য {i}–{j-1}, {w} শব্দ: {text[:30]}…")
print(sentences("দাম ৯৯.৫০ টাকা। ডা. রহিম দেখবেন।"))   # ফাঁদ

# fixed-size: L অক্ষর, chunk s, overlap o হলে chunk-এর সংখ্যা
L, s, o = 1000, 200, 50
print("chunk সংখ্যা:", math.ceil((L - o) / (s - o)))
print("শুরুর অবস্থান:", [k * (s - o) for k in range(math.ceil((L - o) / (s - o)))])

#0 [ইলেকট্রনিক্স] বাক্য 0–1, 23 শব্দ: ইলেকট্রনিক্স পণ্য ৭ দিনের মধ্য…
#1 [ইলেকট্রনিক্স] বাক্য 1–2, 20 শব্দ: বাক্সের সিল খোলা হলে মন বদলের …
#2 [ইলেকট্রনিক্স] বাক্য 2–3, 17 শব্দ: ভাঙা পণ্য পেলে ৪৮ ঘণ্টার মধ্যে…
#3 [যাচাই] বাক্য 0–0, 11 শব্দ: ফেরত আসা পণ্য গুদামে পরীক্ষার …
['দাম ৯৯.৫০ টাকা।', 'ডা.', 'রহিম দেখবেন।']
chunk সংখ্যা: 7
শুরুর অবস্থান: [0, 150, 300, 450, 600, 750, 900]

৩ · Metadata, embedding আর index

প্রতিটি টুকরো একা যায় না। সঙ্গে থাকে তার metadata: কোন নথির (id), শিরোনাম আর উপশিরোনাম, শেষ হালনাগাদের তারিখ, অবস্থা (চালু না পুরনো), ভাষা। এগুলো তিন কাজে লাগে: citation-এ উৎসের নাম দেখানো, খোঁজার আগে বা পরে filter করা, আর টুকরোর লেখার সামনে শিরোনাম জুড়ে দিয়ে তার অর্থ স্পষ্ট করা। “১,৫০০ টাকা বা তার বেশি দামের অর্ডারে ফ্রি” টুকরোটি একা পড়লে বোঝা যায় না কোন এলাকার কথা; “ডেলিভারি চার্জ: ঢাকা সিটি” লেবেলসহ পড়লে যায়।

Embedding-এর জন্য এখানে intfloat/multilingual-e5-small (MIT লাইসেন্স, ৩৮৪-মাত্রার vector). এর model card বলে প্রশ্নের সামনে "query: " আর নথির সামনে "passage: " বসাতে; না বসালে মান কমে বলে কার্ডে সতর্ক করা আছে। দুই পাশের vector normalise করা, তাই dot product-ই cosine similarity. আমাদের ৪০টি নথি থেকে ৪৭টি টুকরো, তাই প্রতিটি প্রশ্নে সব টুকরোর সঙ্গে সরাসরি তুলনাই যথেষ্ট; লাখো টুকরো হলে approximate index লাগে, যা পর্ব ৬৮ · Vector index-এর বিষয়।

পুরনো নথির ফাঁদ, সত্যিকারের run থেকে। Corpus-এ ইচ্ছে করে একটি পুরনো নথি রাখা আছে: “ঢাকা সিটিতে ডেলিভারি চার্জ ৫০ টাকা” (২০২৫, archived). এখনকার নথিতে ৬০ টাকা। “ঢাকা সিটিতে ডেলিভারি চার্জ কত?” প্রশ্নে:

~/bazarghar-dl$ uv run python retrieve.py   # সত্যিকারের run, ছোট করে দেখানো
q03 filter ছাড়া, শীর্ষ ৩:  bh04#0 0.946   bh40#0 0.938 (archived, ৫০ টাকা)   bh28#0 0.917
q03 status == "active":   bh04#0 0.946   bh28#0 0.917   bh06#0 0.901

Filter ছাড়া পুরনো নথিটি দ্বিতীয় স্থানে, score প্রায় সমান (০.৯৪৬ বনাম ০.৯৩৮): embedding “৫০” আর “৬০”-এর পার্থক্য প্রায় দেখে না। এই run-এ Qwen প্রথম উৎস নিয়ে “৬০ টাকা” লিখেছে, কিন্তু দুটি পরস্পরবিরোধী উৎস prompt-এ গেলে কোনটি নেবে, তার নিশ্চয়তা নেই। Metadata filter (status == "active") পুরনো নথিটিকে খোঁজার আগেই বাদ দেয়; নিয়ম হিসেবে এটি prompt-এ “নতুনটি নাও” লেখার চেয়ে নির্ভরযোগ্য।

Query rewriting হলো খোঁজার আগে প্রশ্নটি নতুন করে লেখা। যেমন “ওটা ফেরত দিলে টাকা কবে পাব?”-এ “ওটা” আগের বার্তা থেকে বসানো, Banglish প্রশ্ন বাংলায় আনা, বা প্রশ্ন দুই ভাগ করা; HyDE (Gao ও সহকর্মী, ২০২২) আগে একটি কাল্পনিক উত্তর লিখিয়ে তা দিয়ে খোঁজে। প্রতিটি বাড়তি LLM-ডাক সময় আর খরচ বাড়ায়, আর ভুল rewrite খোঁজাকেই ভুল পথে নেয়। এই run-এ rewriting চালানো হয়নি।

৪ · Retrieval আর reranking — দ্রুত ছাঁকনি, তারপর মনোযোগী বিচার

Embedding-এর model একটি bi-encoder: প্রশ্ন আর টুকরো আলাদাভাবে vector হয়, তাই টুকরোর vector আগে থেকে হিসাব করে রাখা যায়, আর খোঁজা খুব দ্রুত। কিন্তু প্রশ্নের শব্দ আর টুকরোর শব্দ কখনো একসঙ্গে দেখা হয় না। Cross-encoder প্রশ্ন আর একটি টুকরো একসঙ্গে এক Transformer-এ পড়ে (পর্ব ৪৮-এর BERT-এর মতো দুই বাক্যের ইনপুট), আর একটি প্রাসঙ্গিকতার score দেয়। প্রতিটি জোড়ায় একবার model চালাতে হয় বলে সব টুকরোয় চালানো যায় না; তাই প্রথম ধাপের শীর্ষ ১০টিকে নতুন করে সাজানো হয়: reranking. BERT দিয়ে passage reranking-এর পরিচিত প্রথম দিকের কাজ Nogueira ও Cho-র (২০১৯)।

এখানে reranker BAAI/bge-reranker-v2-m3 (Apache 2.0, model card অনুযায়ী বহুভাষিক)। শীর্ষ ১০টি টুকরো embedding দিয়ে, তারপর reranker-এ শীর্ষ ৩টি। ৩৩টি উত্তরযোগ্য প্রশ্নে (সত্যিকারের run):

~/bazarghar-dl$ uv run python retrieve.py && uv run python analyze.py   # সত্যিকারের run, ছোট করে
sentence chunks= 47   fixed chunks= 78
sentence (embed)   all-gold@3 32/33  hit@1 30/33  MRR 0.947
fixed (embed)      all-gold@3 31/33  hit@1 28/33  MRR 0.906
sentence + rerank  all-gold@3 33/33  hit@1 33/33  MRR 1.000
rerank time 1.95 s; peak MB 1111

৫ · Prompt নির্মাণ — নম্বর দেওয়া উৎস আর “উৎসে নেই”

খুঁজে আনা টুকরোগুলো prompt-এ কীভাবে বসবে, তার ওপর উত্তরের মান অনেকটা নির্ভর করে। এই পর্বের system prompt (সত্যিকারের run-এ যা গেছে, হুবহু):

প্রতিটি বাক্যের একটি কাজ আছে। “শুধু উৎস থেকে” model-কে স্মৃতি থেকে বানাতে নিষেধ করে। নম্বর দেওয়া উৎস আর “[1]” রূপের নির্দেশ উত্তরকে যাচাইযোগ্য করে। “উৎসে না থাকলে” একটি নির্দিষ্ট বাক্য দেয়, যা কোড সহজে চিনতে পারে: এটি abstention, অর্থাৎ উত্তর না দেওয়ার সিদ্ধান্ত। শেষ বাক্যটি পর্ব ৬৪-এর নীতি: উৎসের লেখা ডেটা, নির্দেশ নয়। RAG-এর নথিও আক্রমণের পথ হতে পারে (indirect prompt injection), যার মাপা পরীক্ষা পর্ব ৭৩ · LLM নিরাপত্তায়।

আরও কয়েকটি সিদ্ধান্ত: ক্রম (সবচেয়ে প্রাসঙ্গিক টুকরো আগে; লম্বা context-এর মাঝের তথ্য model কম ব্যবহার করতে পারে, Liu ও সহকর্মীদের ২০২৩ সালের “Lost in the Middle” প্রবন্ধের ফল, পর্ব ৫২); লেবেল আর তারিখ প্রতিটি উৎসের সঙ্গে; সংখ্যা k (বেশি টুকরো মানে বেশি token আর বেশি বিভ্রান্তি, কম মানে উত্তর বাদ পড়ার ঝুঁকি)। নিচের stepper-এ একটি দুই-নথির প্রশ্নের সত্যিকারের prompt ধাপে ধাপে, আর তারপর কোডে একই কাজ (টুকরোর লেখা পাতায় রাখা chunks.json থেকে)।

import json
CHUNKS = json.load(open("chunks.json", encoding="utf-8"))   # টুকরোর id → লেখা (run থেকে হুবহু)
HITS = [  # সত্যিকারের retrieval-এর শীর্ষ ৪টি: (টুকরো, cosine, লেবেল, হালনাগাদ)
    ("bh02#0", 0.8803, "রিফান্ড কত দিনে পাবেন", "2026-09-15"),
    ("bh03#0", 0.8436, "ফেরত পাঠানোর খরচ", "2026-08-01"),
    ("bh19#0", 0.8356, "বাজারঘর ওয়ালেট", "2026-03-18"),
    ("bh15#1", 0.8307, "ওয়ারেন্টি দাবি করবেন যেভাবে", "2026-04-02")]

def build(question, hits, k=3, max_words=150):
    picked, words = [], 0
    for cid, score, label, date in hits:                  # score-এর ক্রমেই আসে
        w = len(CHUNKS[cid].split())
        if len(picked) == k or words + w > max_words:
            break
        picked.append((cid, label, date)); words += w
    src = "\n".join(f"[{i}] ({label}, হালনাগাদ {date})\n{CHUNKS[cid]}"
                    for i, (cid, label, date) in enumerate(picked, 1))
    cmap = {i: cid for i, (cid, *_) in enumerate(picked, 1)}   # পরে citation মেলাতে
    return f"উৎস:\n{src}\n\nপ্রশ্ন: {question}", cmap, words

q = "মন বদলে ঢাকার বাইরে থেকে ফেরত দিলে কত টাকা কাটা যাবে, আর bKash-এ রিফান্ড কত দিনে আসবে?"
for k, mw in [(3, 150), (3, 80), (4, 150)]:
    user, cmap, w = build(q, HITS, k, mw)
    print(f"k={k}, শব্দ-সীমা {mw}: {cmap} | উৎসের শব্দ {w} | {len(user)} অক্ষর")
user, cmap, w = build(q, HITS)
for line in user.split("\n"):
    print(line if len(line) < 60 else line[:56] + " …")

k=3, শব্দ-সীমা 150: {1: 'bh02#0', 2: 'bh03#0', 3: 'bh19#0'} | উৎসের শব্দ 117 | 945 অক্ষর
k=3, শব্দ-সীমা 80: {1: 'bh02#0', 2: 'bh03#0'} | উৎসের শব্দ 77 | 662 অক্ষর
k=4, শব্দ-সীমা 150: {1: 'bh02#0', 2: 'bh03#0', 3: 'bh19#0', 4: 'bh15#1'} | উৎসের শব্দ 138 | 1127 অক্ষর
উৎস:
[1] (রিফান্ড কত দিনে পাবেন, হালনাগাদ 2026-09-15)
ফেরত অনুমোদনের পর bKash বা Nagad-এ রিফান্ড ৩ কর্মদিবসের  …
[2] (ফেরত পাঠানোর খরচ, হালনাগাদ 2026-08-01)
ভুল, ক্ষতিগ্রস্ত বা ত্রুটিপূর্ণ পণ্য ফেরত পাঠানোর খরচ বা …
[3] (বাজারঘর ওয়ালেট, হালনাগাদ 2026-03-18)
রিফান্ড আর ক্যাশব্যাকের টাকা বাজারঘর ওয়ালেটে জমা হয়। ও …

প্রশ্ন: মন বদলে ঢাকার বাইরে থেকে ফেরত দিলে কত টাকা কাটা  …

৬ · সত্যিকারের run — no-RAG, RAG আর RAG + rerank

এবার পুরো যন্ত্র। ৪১টি হাতে লেখা প্রশ্ন: ৩৩টির উত্তর নথিতে আছে (দুটি দুই নথির, দুটি ইংরেজি, দুটি Banglish), ৮টির নেই (“বাজারঘর কোন সালে প্রতিষ্ঠিত?”)। তিনটি অবস্থা: no-RAG (শুধু প্রশ্ন, সাধারণ system prompt), RAG (embedding-এর শীর্ষ ৩) আর RAG + rerank (reranker-এর শীর্ষ ৩)। Generator Qwen2.5-1.5B-Instruct, GPU-তে bf16, greedy (do_sample=False, torch.manual_seed(0)), সর্বোচ্চ ১৬০টি নতুন token; সবচেয়ে বেশি GPU মেমরি ৩,০৬০ MB. প্রতিটি উত্তর লেখক নিজে পড়ে রায় দিয়েছেন। নিয়ম: সঠিক তথ্যটি আছে আর প্রশ্ন নিয়ে কোনো ভুল বা বানানো তথ্য নেই (ভাষার ভুল ক্ষমা); উত্তরহীন প্রশ্নে স্পষ্টভাবে “নেই” বলা।

~/bazarghar-dl$ uv run python analyze.py   # সত্যিকারের run, generation অংশ, ছোট করে
norag   answerable-correct 1/33   unanswerable-abstain 0/8  cited 0/33  in_tok 143   sec 3.27
rag     answerable-correct 19/33  unanswerable-abstain 2/8  cited 5/33  in_tok 1022  sec 1.76
rerank  answerable-correct 20/33  unanswerable-abstain 1/8  cited 4/33  in_tok 1011  sec 1.49

কয়েকটি উত্তর হুবহু (seed 0, greedy; লম্বা উত্তর “…” দিয়ে কাটা):

শেষ পর্যবেক্ষণটির একটি সস্তা প্রতিকার আছে, model-এর বাইরে। Reranker প্রতিটি প্রশ্নে সেরা টুকরোর একটি score দেয়। উত্তরযোগ্য ৩৩টির সেরা score সবচেয়ে কম ছিল −২.২, আর উত্তরহীন ৮টির ৭টিতে −৩-এর নিচে। তাই নিয়ম: সেরা score −৩-এর নিচে হলে LLM না ডেকে সরাসরি “উৎসে এই তথ্য নেই”। নিচের কোডে তিন অবস্থার রায় আর এই gate-এর প্রভাব, paired bootstrap দিয়ে (মেশিন লার্নিং কোর্সের পর্ব ২২)।

import numpy as np
# সত্যিকারের run-এর হাতে দেওয়া রায়, ৪১টি প্রশ্ন: প্রথম ৩৩টি উত্তরযোগ্য, শেষ ৮টির উত্তর নথিতে নেই।
# 1 = ঠিক (উত্তরহীন প্রশ্নে ঠিক মানে স্পষ্টভাবে "নেই" বলা)
RES = {"no-RAG":     "00000000010000000000000000000000000000000",
       "RAG":        "10111000010011101111100110011100111000000",
       "RAG+rerank": "11111000010001101111101111011100010001000"}
TOP = [2.8, 6.3, 9.1, 7.8, 5.1, -2.2, 5.5, -1.8, 4.0, 4.4, 6.0, 5.5, 3.8, 3.8,
       6.7, 5.9, -0.5, 7.7, 6.7, 6.1, 4.6, 5.9, 6.1, 2.1, 6.1, 6.8, -1.0, 5.6,
       -2.0, 6.7, 3.3, 2.8, -1.5, -4.5, -6.4, -1.6, -3.3, -7.3, -3.4, -3.4, -7.4]
R = {k: np.array([int(c) for c in v]) for k, v in RES.items()}
gate = np.array(TOP) < -3            # reranker-এর সেরা score -3-এর নিচে: উত্তর না লিখে "নেই"
truth = np.r_[np.zeros(33), np.ones(8)]
R["rerank+gate"] = np.where(gate, truth, R["RAG+rerank"]).astype(int)

for k, v in R.items():
    print(f"{k:12} উত্তরযোগ্য {v[:33].sum():2}/33  উত্তরহীন {v[33:].sum()}/8  মোট {v.mean():.3f}")

rng = np.random.default_rng(0)
idx = rng.integers(0, 41, (10000, 41))      # একই প্রশ্ন-নমুনা সব তুলনায়: জোড়া bootstrap
def ci(a, b):
    d = R[a] - R[b]; bs = d[idx].mean(axis=1)
    lo, hi = np.percentile(bs, [2.5, 97.5])
    return f"{a} − {b}: {d.mean():+.3f} [{lo:+.3f}, {hi:+.3f}]"
print(ci("RAG", "no-RAG"))
print(ci("RAG+rerank", "RAG"))
print(ci("rerank+gate", "RAG+rerank"))

no-RAG       উত্তরযোগ্য  1/33  উত্তরহীন 0/8  মোট 0.024
RAG          উত্তরযোগ্য 19/33  উত্তরহীন 2/8  মোট 0.512
RAG+rerank   উত্তরযোগ্য 20/33  উত্তরহীন 2/8  মোট 0.537
rerank+gate  উত্তরযোগ্য 20/33  উত্তরহীন 7/8  মোট 0.659
RAG − no-RAG: +0.488 [+0.341, +0.634]
RAG+rerank − RAG: +0.024 [-0.098, +0.146]
rerank+gate − RAG+rerank: +0.122 [+0.024, +0.220]

৭ · Citation যাচাই — নম্বর আছে, প্রমাণ আছে কি?

Citation যাচাই উত্তর ব্যবহারকারীর কাছে যাওয়ার আগের শেষ পাহারা। সস্তা কয়েকটি পরীক্ষা কোডেই হয়: (১) উত্তরে “নেই”-এর নির্দিষ্ট বাক্য আছে কি; (২) [n] নম্বরগুলো ১ থেকে k-এর মধ্যে কি না; (৩) উত্তরের প্রতিটি সংখ্যা উদ্ধৃত উৎসে আছে কি না, আর নম্বর না থাকলে অন্তত কোনো একটি উৎসে। বাংলায় দুটি খুঁটিনাটি: বাংলা অঙ্ক ইংরেজিতে আনা, আর “২০,০০০”-এর কমা সরানো। নিচের stepper একটি সত্যিকারের উত্তর এভাবে যাচাই করে।

নিচের কোড একই নিয়ম ছয়টি সত্যিকারের উত্তরে চালায়; উত্তর আর টুকরো পাতায় রাখা দুটি JSON ফাইলে, run থেকে হুবহু।

import json, re
CHUNKS = json.load(open("chunks.json", encoding="utf-8"))     # টুকরোর id → লেখা
CASES = json.load(open("answers.json", encoding="utf-8"))     # Qwen2.5-1.5B-এর সত্যিকারের উত্তর
B2E = str.maketrans("০১২৩৪৫৬৭৮৯", "0123456789")
ABSTAIN = "উৎসে এই তথ্য নেই"

def numbers(text):                        # "২০,০০০" → 20000; [n] বাদ
    text = re.sub(r"\[[0-9০-৯]+\]", " ", text.translate(B2E))
    text = re.sub(r"(?m)^\s*\d+\.", " ", text)         # তালিকার "1." সংখ্যা নয়
    return {int(n.replace(",", "")) for n in re.findall(r"\d[\d,]*", text)}

def check(case):
    src = [CHUNKS[c] for c in case["src"]]
    ans = case["answer"]
    cites = [int(x.translate(B2E)) for x in re.findall(r"\[([0-9০-৯]+)\]", ans)]
    if ABSTAIN in ans:
        return "নেই বলেছে" + (f" (তবু cite {cites})" if cites else "")
    bad = [n for n in cites if not 1 <= n <= len(src)]
    if bad:
        return f"অচল cite {bad}"
    pool = [src[n - 1] for n in cites] or src      # cite না থাকলে সব উৎস
    have = set().union(*(numbers(s) for s in pool))
    miss = numbers(ans) - have
    where = f"cite {cites}" if cites else "cite নেই, সব উৎস"
    return f"{where}; সংখ্যা {sorted(numbers(ans))} → " + (f"উৎসে নেই {sorted(miss)}" if miss else "সব উৎসে আছে")

for c in CASES:
    print(f"{c['q']} {c['run']:6} {check(c)}")

q05 rag    cite নেই, সব উৎস; সংখ্যা [90] → সব উৎসে আছে
q06 rag    cite নেই, সব উৎস; সংখ্যা [300] → উৎসে নেই [300]
q09 rerank cite নেই, সব উৎস; সংখ্যা [20] → সব উৎসে আছে
q11 rag    cite [1]; সংখ্যা [20000] → সব উৎসে আছে
u04 rerank cite [2]; সংখ্যা [500] → সব উৎসে আছে
q33 rerank নেই বলেছে (তবু cite [1])

৮ · Framework আর ছয়টি পণ্যের নথি

এই পর্বের পুরো pipeline প্রায় ১৫০ লাইনের নিজের Python: chunker, sentence-transformers দিয়ে embedding, NumPy-তে খোঁজা, transformers দিয়ে reranker আর generator. ইচ্ছে করেই কোনো framework নেই, যাতে প্রতিটি ধাপ চোখে পড়ে। বাস্তবে অনেক দল framework ব্যবহার করে: LangChain (২০২২ সালে Harrison Chase শুরু করেন), LlamaIndex (আগের নাম GPT Index, Jerry Liu, ২০২২) আর deepset-এর Haystack. এগুলোতে document loader, text splitter আর বহু vector database-এর সংযোগ তৈরি থাকে। সুবিধা দ্রুত শুরু; ঝুঁকি ডিফল্ট মান (chunk-এর আকার, prompt) চোখের আড়ালে থাকা আর version-এর সঙ্গে API বদলানো।

Hosted assistant-গুলোর API-তেও “নিজের ফাইল থেকে উত্তর” সুবিধা আছে, তবে রূপ আলাদা। নিচের সারণি প্রতিটি কোম্পানির নিজের নথি থেকে, লেখার সময়ে (নভেম্বর ২০২৬) পড়া; পরিবর্তন হতে পারে, ব্যবহারের আগে নথি নিজে মিলিয়ে নিন। যেখানে পড়া পাতায় বিষয়টি পাইনি, সেখানে “নথিতে পাইনি”। কোনটি ভালো, সারণি তা বলে না।

সারণির শিক্ষা: কেউ পুরো retrieval নিজে চালায় (OpenAI, Google, xAI), কেউ শুধু citation-এর কাঠামো দেয় আর খোঁজা আপনার হাতে রাখে (Anthropic), কেউ পুরো ফাইল context-এ দিতে বলে (Kimi). Hosted ব্যবস্থায় chunk-এর আকার, embedding model বা reranking কতটা দেখা ও বদলানো যায়, তা সীমিত; নিজের pipeline-এ সব আপনার হাতে, দায়ও। নিচে দুটি অনুরোধের আকার, নথির কাঠামো অনুসরণ করে লেখা; চালানো হয়নি, কারণ এখানে কোনো API key নেই।

# নমুনা (চালানো হয়নি): শুধু body-র মূল অংশ; model-এর নাম নিজে বসান
# OpenAI Responses API, hosted file search
{"model": "…", "input": "ঢাকা সিটিতে ডেলিভারি চার্জ কত?",
 "tools": [{"type": "file_search", "vector_store_ids": ["vs_…"],
            "max_num_results": 3}],
 "include": ["file_search_call.results"]}
# Claude Messages API: নিজের খোঁজার ফল search_result হিসেবে
{"model": "…", "max_tokens": 300, "messages": [{"role": "user", "content": [
  {"type": "search_result", "source": "kb://bh04", "title": "ডেলিভারি চার্জ: ঢাকা সিটি",
   "content": [{"type": "text", "text": "ঢাকা সিটি কর্পোরেশনের ভেতরে …"}],
   "citations": {"enabled": true}},
  {"type": "text", "text": "ঢাকা সিটিতে ডেলিভারি চার্জ কত?"}]}]}

৯ · AI-এর যুগে — RAG-এর কোড আর দাবি যাচাই

AI assistant কয়েক মিনিটে একটি RAG demo লিখে দেয়। কাজ করে বলে মনে হয়, কারণ demo-র প্রশ্নে উত্তর মেলে। ভুলগুলো চুপচাপ থাকে:

RAG-এর চেকলিস্ট

• নিজের নথিতে chunk ছাপিয়ে দেখেছি: বাক্য বা সংখ্যা মাঝখানে কাটেনি
• প্রতিটি টুকরোয় নথির id, শিরোনাম, তারিখ আর অবস্থা আছে; পুরনো নথি filter হয়
• Embedding model-এর card-এর নিয়ম (prefix, normalise) মেনেছি
• Prompt-এ শুধু উৎস, নম্বর দেওয়া, আর “উৎসে নেই” বলার পথ আছে
• Citation-এর নম্বর আর উত্তরের সংখ্যা কোডে যাচাই হয়
• উত্তরহীন প্রশ্নসহ eval set-এ মেপেছি, n আর CI-সহ