रैग के लिए क्लीन वेब टेक्स्ट: एक फ़ेच, एक्सट्रेक्ट, और चंक पाइपलाइन

मुख्य बिंदु:

• आरएजी गुणवत्ता का मतलब मेट्रिक्स की गुणवत्ता है। पुनर्प्राप्ति उत्तर केवल उस पाठ की गुणवत्ता के बराबर होते हैं जिसे आपने अनुक्रमित किया है - और अधिकांश पाइपलाइन विफलताएँ उन पृष्ठों की ओर इशारा करती हैं जो कभी दिखे नहीं, नेविगेशन क्रोम जो एम्बेडेड हो गया, या उस खंड को जो विचार के बीच में काट दिया गया।
• फेचिंग अविश्वसनीय चरण है। आधुनिक पृष्ठ जावास्क्रिप्ट-रेन्डर्ड और बॉट-चेक होते हैं; एक साधारण HTTP GET एक खाली खोल या एक चुनौती पृष्ठ लौटाता है, और यह कचरा आपके वेक्टर स्टोर में चुपचाप प्रवाहित हो जाता है।
• एक POST रेन्डर्ड पृष्ठ लौटाता है। स्क्रैपलेस वेब अनलॉकर एक URL लेता है और पूर्ण रूप से रेन्डर्ड HTML लौटाता है जैसे {"code": 200, "data": "<html…>"} — रेन्डरिंग और एंटी-बॉट प्रबंधन सर्वर-साइड पर चलता है।
• निकालना घटाना है। पाठ पढ़ने से पहले स्क्रिप्ट, शैली, नेविगेशन, और फूटर हटा दें; जो बचता है वह एम्बेडिंग के योग्य गद्य है।
• ओवरलैप के साथ खंड बनाएं, प्रावेंस बनाए रखें। ओवरलैप के साथ निश्चित शब्द विंडो सीमाओं के पार संदर्भ को बरकरार रखते हैं, और हर खंड को इसका स्रोत URL ले जाना चाहिए — प्रावेंस के बिना पुनर्प्राप्ति का ऑडिट नहीं किया जा सकता है।
• शुरुआत के लिए स्वतंत्र। नए स्क्रैपलेस खाते में मुफ्त परीक्षण क्रेडिट शामिल हैं - app.scrapeless.com पर साइन अप करें।

पाइपलाइन एक नजर में

एक आरएजी प्रणाली पाठ के खंडों को पुनर्प्राप्त करती है और उन्हें एक मॉडल को प्रदान करती है; सब कुछ डाउनस्ट्रीम उस सामग्री को विरासत में लेता है जो अनुक्रमित हुई है। यह गाइड अंत से अंत तक अधिग्रहण पक्ष का निर्माण करता है:

1. फेच करें — वेब अनलॉकर के माध्यम से URL सूची के लिए पूर्ण रूप से रेन्डर्ड HTML खींचें, ताकि जावास्क्रिप्ट-निर्मित पृष्ठ और बॉट-चेक की गई साइटें असली सामग्री लौटाएँ।
2. निकालें — पृष्ठ क्रोम को हटा दें और गद्य को बनाए रखें।
3. खंड करें — ओवरलैपिंग शब्द विंडो में विभाजित करें, किसी भी एम्बेडिंग मॉडल और वेक्टर स्टोर के लिए तैयार करें।

आउटपुट corpus.jsonl है: प्रति पंक्ति एक खंड इसके स्रोत URL और स्थान के साथ — तटस्थ प्रारूप जिसे हर एम्बेडिंग वर्कफ़्लो स्वीकार करता है। चरण 2 और 3 शुद्ध परिवर्तन हैं; केवल चरण 1 नेटवर्क को छूता है।

क्यों फेच चरण पहले टूटता है

वेब-पाठ अधिग्रहण में तीन विफलता मोड प्रमुख हैं, और तीनों तब तक अदृश्य हैं जब तक पुनर्प्राप्ति गुणवत्ता घटती नहीं है:

• क्लाइंट-साइड रेंडरिंग। एक साधारण GET जो HTML लौटाता है वह एक लोडर खोल है; लेख बाद में जावास्क्रिप्ट के माध्यम से आता है। आपका एक्सट्रैक्टर एक खाली <div id="root"> पढ़ता है और कुछ अनुक्रमित नहीं करता।
• एंटी-बॉट इंटरस्टिशियल्स। चुनौती पृष्ठ HTTP 200 के साथ "आपके ब्राउज़र की जांच हो रही है" गद्य लौटाते हैं - जो खूबसूरत तरीके से एम्बेड होते हैं और आत्मविश्वास से पुनर्प्राप्त होते हैं।
• सॉफ्ट-404s। मृत URLs जो एक स्टाइल्ड "नहीं मिला" पृष्ठ प्रदर्शित करते हैं, फिर से 200 स्थिति के साथ।

समस्या का समाधान उस अवसंरचना के माध्यम से फेच करना है जो उन परतों को सर्वर-साइड पर प्रस्तुत और साफ करती है। यूनिवर्सल स्क्रैपिंग API वेब अनलॉकर ठीक यही करता है: प्रति URL एक POST, लौटाई गई रेन्डर्ड HTML।

पूर्वापेक्षाएँ

• एक स्क्रैपलेस खाता और API कुंजी - app.scrapeless.com पर साइन अप करें।
• Python 3.10+ जिसमें requests और beautifulsoup4 हो।
• एक URL सूची जिसे आप अधिग्रहण करने का अधिकार रखते हैं (नीचे स्रोत नोट देखें)।

export SCRAPELESS_API_KEY=your_api_token_here

चरण 1 — रेन्डर्ड पृष्ठों को फ़ेच करें

अनलॉकर एंडपॉइंट पर प्रति URL एक POST। प्रतिक्रिया JSON है जिसमें data में रेन्डर्ड दस्तावेज है:

# fetch.py — URL सूची -> pages/*.html (पूर्ण रूप से रेन्डर्ड)
import os
import pathlib

import requests

ENDPOINT = "https://api.scrapeless.com/api/v1/unlocker/request"
HEADERS = {
    "Content-Type": "application/json",
    "x-api-token": os.environ["SCRAPELESS_API_KEY"],
}

URLS = [
    "https://www.scrapeless.com/hi/blog/best-llm-scrapers-2026",
    "https://www.scrapeless.com/hi/blog/google-ai-overview-scraper-api-2026",
]

pathlib.Path("pages").mkdir(exist_ok=True)
for url in URLS:
    resp = requests.post(
        ENDPOINT,
        headers=HEADERS,
        json={
            "actor": "unlocker.webunlocker",
            "input": {"url": url, "type": "html", "redirect": True, "method": "GET"},
        },
        timeout=120,
    )
    resp.raise_for_status()
    html = resp.json()["data"]
    name = url.rstrip("/").rsplit("/", 1)[-1] + ".html"
    pathlib.Path("pages", name).write_text(html, encoding="utf-8")
    print(f"{url} -> pages/{name} ({len(html):,} bytes)")

एक स्वस्थ फ़ेच प्रति लेख पृष्ठ सैकड़ों किलोबाइट्स के रेन्डर्ड दस्तावेज़ को लाता है। कुछ किलोबाइट्स आमतौर पर एक खोल या एक इंटरस्टिशियल का अर्थ है - इसे अनुक्रमण तक पहुँचने से पहले जांचना महत्वपूर्ण है।

अपने API कुंजी को मुफ्त योजना पर प्राप्त करें: app.scrapeless.com

चरण 2 और 3 — गद्य को निकालें, प्रावेंस के साथ खंड करें

Here is the translation of the provided text into Hindi:

निष्कर्षण घटाव है: उन तत्वों को हटा दें जो कभी गद्य नहीं होते, फिर शेष से पाठ पढ़ें।.chunking एक निश्चित शब्द विंडो है जिसमें ओवरलैप होता है, और हर चंक अपने स्रोत यूआरएल और स्थिति को बनाए रखता है:

# build_corpus.py — pages/*.html -> corpus.jsonl (स्रोत के साथ चंक्स)
import json
import pathlib

from bs4 import BeautifulSoup

CHUNK_WORDS = 220      # विंडो का आकार
OVERLAP_WORDS = 40     # अगले चंक में ले जाया गया

STRIP_TAGS = ["script", "style", "noscript", "nav", "header", "footer", "aside", "form", "svg"]

def extract_text(html: str) -> str:
    soup = BeautifulSoup(html, "html.parser")
    for tag in soup(STRIP_TAGS):
        tag.decompose()
    root = soup.find("article") or soup.find("main") or soup.body or soup
    text = root.get_text(" ", strip=True)
    return " ".join(text.split())

def chunk(words: list[str]):
    step = CHUNK_WORDS - OVERLAP_WORDS
    for start in range(0, max(len(words) - OVERLAP_WORDS, 1), step):
        yield start, " ".join(words[start:start + CHUNK_WORDS])

total = 0
with open("corpus.jsonl", "w", encoding="utf-8") as out:
    for page in sorted(pathlib.Path("pages").glob("*.html")):
        text = extract_text(page.read_text(encoding="utf-8"))
        words = text.split()
        for start, body in chunk(words):
            out.write(json.dumps({
                "source": page.stem,
                "word_offset": start,
                "n_words": len(body.split()),
                "text": body,
            }) + "\n")
            total += 1
        print(f"{page.name}: {len(words):,} शब्द")

print(f"{total} चंक्स -> corpus.jsonl")

जो निकलता है, हर चंक के लिए एक पंक्ति:

// व्याख्यात्मक उदाहरण — सक्रिय build_corpus.py चलाने से स्कीमा; पाठ संक्षिप्त
{
  "source": "best-llm-scrapers-2026",
  "word_offset": 180,
  "n_words": 220,
  "text": "…अभिनेता उत्तर के साथ इसके संदर्भ के रूप में संरचित क्षेत्रों के रूप में लौटता है…"
}

यहां से, कोई भी एम्बेडिंग कार्यप्रवाह आगे लेता है: corpus.jsonl पढ़ें, text एम्बेड करें, वेक्टर को source और word_offset के रूप में मेटाडेटा के साथ स्टोर करें। प्रवीणता डेटा ये हैं जो आपको खराब रिक्ति का पता लगाने में मदद करते हैं कि यह किस पृष्ठ और स्थिति से आया।

जिम्मेदारी से स्रोत करना

एक प्रशिक्षण या पुनर्प्राप्ति कॉर्पस अपने स्रोतों से कानूनी वजन विरासत में लेता है। केवल सार्वजनिक रूप से सुलभ पृष्ठों को ही संकलित करें जिसका उपयोग करने का आपको अधिकार है; URL सूची में जोड़ने से पहले प्रत्येक साइट के सेवा की शर्तें और रोबोट निर्देशक की जाँच करें; प्रति होस्ट अनुरोध मात्रा को समुचित रखें; और कॉपीराइटेड पाठ को कुछ ऐसा मानें जिसे आप पुनर्प्रकाशित करने के बजाय पुनर्प्राप्त और श्रेय देते हैं। जब एक कॉर्पस में तीसरे पक्ष का सामग्री शामिल होता है, तो source फ़ील्ड को अक्षुण्ण रखना एक उद्धरण और एक प्रति के बीच का अंतर है।

अक्सर पूछे जाने वाले प्रश्न

प्रश्न: URLs पर सीधे requests.get का उपयोग क्यों नहीं करें?

स्थिर पृष्ठों के लिए यह काम करता है। जावास्क्रिप्ट-निर्मित या बॉट-चेक किए गए साइटों के लिए, यह शेल और अंतर्वार्ता लौटाता है जो चुपचाप अनुक्रमणिका को विषाक्त करते हैं — अनलॉकर विशेष रूप से उनके लिए मौजूद है।

प्रश्न: चंक्स कितने बड़े होने चाहिए?

यहां 220/40 विंडो वाक्य-परिवर्तक-क्लास एम्बेडिंग मॉडलों के लिए एक यथ reasonable म डिफ़ॉल्ट है। अपने मॉडल के संदर्भ और आपकी पुनर्प्राप्ति की बारीकी के लिए ट्यून करें; कुछ ओवरलैप रखें ताकि सीमाओं को पार करने वाले विचारों को जीवित रखा जा सके।

प्रश्न: क्या मैं अनुक्रमणिका तक पहुंचने से पहले खराब फ़ेच का पता कैसे लगा सकता हूँ?

आकार और सामग्री की जाँच: प्रस्तुत लेख पृष्ठ बड़े होते हैं (कार्य उदाहरण के पृष्ठ सैकड़ों किलोबाइट में आते हैं), और एक पृष्ठ से निकाला गया पाठ जो एक लेख होना चाहिए, कुछ सौ शब्दों के तहत एक लाल झंडा है जिसे लॉग करना मूल्यवान है।

प्रश्न: क्या यह भारी एंटी-बॉट विक्रेताओं के पीछे पृष्ठों को फ़ेच कर सकता है?

अनलॉकर का काम सर्वर-साइड एंटी-बॉट परतों को साफ करना है। जहां कोई विशिष्ट पृष्ठ अभी भी साफ नहीं किया जा सकता है, इसे अनफेच करने योग्य मानें और छोड़ दें — एक गायब पृष्ठ पुनर्प्राप्त योग्य है, एक विषाक्त अनुक्रमणिका नहीं है।

प्रश्न: क्या मुझे एक प्रॉक्सी की आवश्यकता है?

नहीं। एग्रस और रेंडरिंग अभिनेता के अंदर संभाली जाती हैं; आप जो POST भेजते हैं वह पूरे एकीकरण है।

प्रश्न: एम्बेडिंग और वेक्टर स्टोर कब आते हैं?

corpus.jsonl के डाउनस्ट्रीम, जिनके साथ आप पहले से ही उपयोग करते हैं। यह पाइपलाइन जानबूझकर साफ, प्रवीणता-टैग किए गए चंक्स पर रुकती है — हर एम्बेडिंग उपकरण द्वारा स्वीकार किया गया प्रारूप।

निष्कर्ष: साफ अंदर, साफ बाहर

इंजेशन पाइपलाइन तीन छोटी फ़ाइलों में घटित होती है: अनलॉकर के माध्यम से प्रस्तुत HTML लाना, चांदनी को घटाना, ओवरलैप और प्रवीणता के साथ चंक करना। इनमें से कोई भी आकर्षक नहीं है, और सभी यह तय करते हैं कि पुनर्प्राप्ति का उत्तर वास्तविक लेख पाठ से आता है या अनुक्रमणिका में लोडर शेल से जो फिसल गया। URL सूची को उन स्रोतों की ओर इंगित करें जिन्हें आपका सहायक जानना चाहिए, चलाने का कार्यक्रम तय करें, और कच्चे पृष्ठों को रखें — वे ऑडिट ट्रेल हैं।

क्या आप अपने RAG इंजestion पाइपलाइन का निर्माण करने के लिए तैयार हैं?

हमारा समुदाय ज्वाइन करें ताकि एक मुफ्त योजना प्राप्त कर सकें और डेटा पाइपलाइन तैयार करने वाले विकासकर्ताओं से जुड़ सकें: Discord · Telegram।
app.scrapeless.com पर मुफ्त परीक्षण क्रेडिट के लिए साइन अप करें, और फ़ेच चरण को उन पृष्ठों की ओर इंगित करें जिनकी आवश्यकता आपके पुनर्प्राप्ति कोर्पस को है। वर्तमान स्तरों के लिए मूल्य निर्धारण देखें।