ScrapeGraphAI + Scrapeless: Cloud ब्राउज़र पर SmartScraperGraph को पॉइंट करें

TL;DR:

• ScrapeGraphAI प्रम्ट के साथ चयनकर्ताओं के बजाय निकालता है, लेकिन इसके पीछे का फ़ेचिंग आपके अपने मशीन पर लॉन्च किए गए एक सामान्य Playwright ब्राउज़र पर आधारित है।
• pip install scrapegraphai आपको Playwright क्लाइंट देता है और कोई ब्राउज़र बाइनरी नहीं है, इसलिए स्टॉक लोडर एक ताज़ा इंस्टॉलेशन पर विफल हो जाता है जब तक आप playwright install chromium नहीं चलाते।
• ChromiumLoader अपने फ़ेच विधि को getattr(self, f"ascrape_{self.backend}") के साथ चुनता है, इसलिए backend एक विधि का नाम बताता है बजाय एक निश्चित सूची से चुनने के — यही वह जगह है जहाँ एक कस्टम फ़ेच बैकएंड लटका होता है।
• एक छोटा उपक्लास एक ascrape_scrapeless विधि के साथ Scrapeless Scraping Browser के माध्यम से एक wss:// CDP कनेक्शन के माध्यम से फ़ेच करता है और स्थानीय रूप से कोई ब्राउज़र स्थापित करने की आवश्यकता नहीं है।
• FetchNode ChromiumLoader को नाम से आयात करता है, इसलिए fetch_node.ChromiumLoader को पुनर्बाइंड करना वास्तव में आपके उपक्लास का उपयोग करने के लिए ग्राफ को बनाता है। इसे छोड़ दें और एक सही दिखने वाला लोडर चुपचाप नजरअंदाज किया जाता है।
• पूरा पाइपलाइन एक स्थानीय मॉडल पर चलता है: SmartScraperGraph के साथ ollama/qwen2.5:0.5b ने संरचित लेखक और उद्धरण जोड़े को बिना किसी क्लाउड मॉडल कुंजी के वापस किया।
• Scrapeless मुफ्त योजना पर शुरू करें और फ़ेच को अपने लैपटॉप से हटा दें।

Scrapeless Scraping Browser एक क्लाउड ब्राउज़र है जिससे आप जुड़े रहते हैं बजाय इसे लॉन्च करने के। यह एक सुरक्षित WebSocket CDP अंत बिंदु पर सुनता है, जो यहाँ महत्वपूर्ण है क्योंकि ScrapeGraphAI की फ़ेच परत के नीचे Playwright होता है और Playwright एक ब्राउज़र से जुड़ सकता है जिसे उसने शुरू नहीं किया।

ScrapeGraphAI वह भाग है जिसके बारे में लोग बात करते हैं: आप जो चाहते हैं उसे एक वाक्य में वर्णित करें, और नोड्स का एक ग्राफ एक पृष्ठ को संरचित JSON में बदल देता है बिना एक भी CSS चयनकर्ता के। वह भाग जिसके बारे में कोई बात नहीं करता वह पहला नोड है। किसी भी मॉडल से पहले FetchNode को HTML उत्पन्न करना होता है, और यह क्रोमियम को उस मशीन पर चलाकर ऐसा करता है जिस पर स्क्रिप्ट चल रही है। खोज परिणामों के पहले पृष्ठ पर प्रत्येक ट्यूटोरियल उस नोड को ठीक एक ही तरीके से कॉन्फ़िगर करता है, एक प्रॉक्सी डिक्शनरी के साथ, और वहीं रुक जाता है।

यह गाइड फ़ेच परत पर जाती है: यह कहाँ रहती है, वास्तविक विस्तार बिंदु क्या है, और इसे क्लाउड ब्राउज़र के माध्यम से कैसे राउट किया जाए। नीचे हर ब्लॉक लाइव चला है, जिसमें निष्कर्षण भी शामिल है।

Where ScrapeGraphAI's Fetch Layer Actually Lives

FetchNode लगभग हर ग्राफ का प्रवेश नोड है, और यह कुछ शाखाओं में से एक पर समाप्त होता है। यदि आप browser_base, scrape_do, या plasmate को नोड कॉन्फ़िगरेशन में सेट करते हैं, तो यह scrapegraphai/docloaders/ में एक विक्रेता लोडर को सौंपता है। अन्यथा, यह ChromiumLoader पर गिर जाता है, जो डिफ़ॉल्ट रास्ता है और हर कोई लगभग इसका उपयोग करता है।

वह बैकअप दो कारणों से महत्वपूर्ण है। विक्रेता फ़ेच बैकएंड पहले से ही इस कोडबेस में स्थापित आकार में हैं बजाय कुछ ऐसा जो आप आविष्कार कर रहे हों - browser_base.py और scrape_do.py रिपॉजिटरी में शिप करते हैं। और ChromiumLoader अपने खुद के फ़ेच विधि का चयन नाम से करता है:

scraping_fn = getattr(self, f"ascrape_{self.backend}")

backend एक निश्चित एनम के खिलाफ मान्य नहीं है। यह एक विशेषता लुकअप में स्ट्रिंग इंटरपोलेशन है, इसलिए कोई भी विधि जिसमें ascrape_<something> नाम है, backend को <something> पर सेट करके पहुँची जा सकती है। यही वह जगह है।

डिफ़ॉल्ट ascrape_playwright p.chromium.launch(...) को कॉल करता है, जो स्थानीय रूप से एक ब्राउज़र प्रक्रिया शुरू करता है। पहले से चल रहे ब्राउज़र के लिए एक WebSocket कनेक्शन के लिए इसे स्वैप करना एक कॉल का परिवर्तन है।

Prerequisites

• Python 3.10 या बाद का।
• डैशबोर्ड से एक Scrapeless API कुंजी, जो SCRAPELESS_KEY के रूप में निर्यात की गई है।
• यदि आप क्लाउड मॉडल कुंजी के बिना निष्कर्षण चरण का पालन करना चाहते हैं तो ओल्लामा स्थानीय रूप से एक खींचे गए मॉडल के साथ चल रहा है।
• क्लाउड पथ के लिए कोई स्थानीय ब्राउज़र बाइनरी की आवश्यकता नहीं है। आपको केवल एक की आवश्यकता है यदि आप स्टॉक लोडर भी चलाना चाहते हैं।

Install

pip install "scrapegraphai==2.1.6" "langchain-ollama==1.1.0"

Playwright एक निर्भरता के रूप में आता है, लेकिन इसके ब्राउज़र नहीं आते। उस भेद से अधिकांश लोग जो पहले विफलता का सामना करते हैं।

export SCRAPELESS_KEY="your_api_key_here"

What a Fresh Install Actually Fetches

स्थापित करने के तुरंत बाद स्टॉक लोडर चलाएँ और यह पृष्ठ पर बिल्कुल भी नहीं पहुँचता।

from scrapegraphai.docloaders import ChromiumLoader

try:
    docs = ChromiumLoader(["https://quotes.toscrape.com/"], headless=True).load()
    print("chars:", len(docs[0].page_content))
except Exception as exc:
    print(f"{type(exc).__name__}: {str(exc).split(' at /')[0]}")

RuntimeError: Failed to scrape after 1 attempts: BrowserType.launch: Executable doesn't exist

Playwright क्लाइंट स्थापित है; क्रोमियम जिसे यह लॉन्च करना चाहता है, वह नहीं है। playwright install chromium इसे ठीक करता है और हर मशीन पर कुछ सौ मेगाबाइट लागत होती है जो ग्राफ चलाता है - एक CI इमेज, एक कंटेनर, प्रत्येक डेवलपर लैपटॉप। क्लाउड पथ इसे पूरी तरह से छोड़ देता है, क्योंकि जिस ब्राउज़र को यह चलाता है वह पहले से कहाँ और चल रहा है।

Point the Loader at a Cloud Browser

ChromiumLoader का उपक्लास बनाएं, उस बैकएंड के लिए एक विधि जोड़ें जिसे आप चाहते हैं, और self.backend को पुनर्बाइंड करें जब super().__init__ चल चुका हो।

import os

from scrapegraphai.docloaders import ChromiumLoader

CDP = (
    "wss://browser.scrapeless.com/api/v2/browser"
    f"?token={os.environ['SCRAPELESS_KEY']}&sessionTTL=180&proxyCountry=ANY"
)


class ScrapelessLoader(ChromiumLoader):
    """Fetch through a remote CDP browser instead of launching one locally."""

    def __init__(self, urls, **kwargs):
        kwargs.pop("backend", None)
        super().__init__(urls, backend="playwright", **kwargs)
        self.backend = "scrapeless"

    async def ascrape_scrapeless(self, url: str, browser_name: str = "chromium") -> str:
        from playwright.async_api import async_playwright

        async with async_playwright() as p:
            browser = await p.chromium.connect_over_cdp(CDP)
            page = await browser.new_page()
            await page.goto(url, wait_until=self.load_state)
            html = await page.content()
            await browser.close()
            return html


loader = ScrapelessLoader(["https://quotes.toscrape.com/"])
print("dispatches to:", getattr(loader, f"ascrape_{loader.backend}").__name__)
docs = loader.load()
print("chars:", len(docs[0].page_content))
print("Einstein present:", "Einstein" in docs[0].page_content)

दो विवरण काम करते हैं। super().__init__ को backend="playwright" के साथ बुलाया जाता है क्योंकि कंस्ट्रक्टर उस स्ट्रिंग के खिलाफ एक आयात जांच चलाता है, और playwright वह नाम है जो हल होता है; self.backend फिर से असाइन किया जाता है ताकि lazy_load में वितरक ascrape_scrapeless को खोज सके। सिग्नेचर में browser_name को एक डिफ़ॉल्ट के साथ बनाए रखें - वितरक URL के साथ केवल विधि को कॉल करता है।

dispatches to: ascrape_scrapeless
chars: 10968
Einstein present: True

पृष्ठ पूरी तरह से एक ब्राउज़र से वापस आता है जो इस मशीन पर कभी अस्तित्व में नहीं था। proxyCountry तब स्वीकार करता है जब आपको अनुरोध को किसी विशेष देश से बाहर जाने की आवश्यकता होती है, और sessionTTL यह सीमित करता है कि दूरस्थ सत्र कितनी देर तक खुला रहता है।

ग्राफ का उपयोग करने के लिए बनाना

स्वयं उपवर्ग को इंस्टेंटिएट करना साबित करता है कि फ़ेच काम करता है, लेकिन ग्राफ इसे अपने आप नहीं उठाएगा। FetchNode from ..docloaders import ChromiumLoader करता है और फिर सीधे उस नाम को कॉल करता है, इसलिए ग्राफ द्वारा उपयोग की जाने वाली कक्षा वह है जो नोड के मॉड्यूल नामांकित स्थान में बंधी होती है। ग्राफ बनाने से पहले इसे फिर से बांधें।

import scrapegraphai.nodes.fetch_node as fetch_node

fetch_node.ChromiumLoader = ScrapelessLoader

यह चरण निर्धारित करता है कि उपरोक्त में से कोई भी प्रभाव डालता है या नहीं। एक उपवर्ग जो सही ढंग से लिखा गया है लेकिन कभी बंधा नहीं जाता है, एक ग्राफ उत्पन्न करता है जो चलता है, सफल होता है, और पूरे समय स्थानीय ब्राउज़र के माध्यम से चुपचाप फ़ेच करता है।

क्योंकि प्रतिस्थापन समान कंस्ट्रक्टर सिग्नेचर को बनाए रखता है, सब कुछ FetchNode पहले से ही पास करता है - headless, storage_state, और कुछ भी जो आप loader_kwargs में डालते हैं - सही-सलामत आता रहता है।

क्या आप फ़ेच को अपनी मशीनों से बाहर ले जाने के लिए तैयार हैं? एक मुफ्त Scrapeless खाता बनाएँ और अपने पहले ग्राफ को इसकी ओर इंगित करें।

स्थानीय मॉडल पर पूरा ग्राफ चलाएँ

लॉ़डर को बांधने के बाद, SmartScraperGraph सामान्य रूप से व्यवहार करता है। llm ब्लॉक को ओलामा पर इंगित करना पूरे पाइपलाइन को सस्ते API से दूर रखता है, जिससे फ़ेच परत पर iteration करना कम खर्चीला हो जाता है।

import os

import scrapegraphai.nodes.fetch_node as fetch_node
from scrapegraphai.docloaders import ChromiumLoader
from scrapegraphai.graphs import SmartScraperGraph

CDP = (
    "wss://browser.scrapeless.com/api/v2/browser"
    f"?token={os.environ['SCRAPELESS_KEY']}&sessionTTL=180&proxyCountry=ANY"
)


class ScrapelessLoader(ChromiumLoader):
    def __init__(self, urls, **kwargs):
        kwargs.pop("backend", None)
        super().__init__(urls, backend="playwright", **kwargs)
        self.backend = "scrapeless"

    async def ascrape_scrapeless(self, url: str, browser_name: str = "chromium") -> str:
        from playwright.async_api import async_playwright

        async with async_playwright() as p:
            browser = await p.chromium.connect_over_cdp(CDP)
            page = await browser.new_page()
            await page.goto(url, wait_until=self.load_state)
            html = await page.content()
            await browser.close()
            return html


fetch_node.ChromiumLoader = ScrapelessLoader

graph = SmartScraperGraph(
    prompt="List the quote authors on this page.",
    source="https://quotes.toscrape.com/",
    config={
        "llm": {
            "model": "ollama/qwen2.5:0.5b",
            "temperature": 0,
            "format": "json",
            "model_tokens": 4096,
        },
        "verbose": False,
        "headless": True,
    },
)
result = graph.run()
print("keys:", sorted(result))
print("authors:", [item["author"] for item in result["content"]][:4])

keys: ['content']
authors: ['Albert Einstein', 'J.K. Rowling', 'Jane Austen', 'Marilyn Monroe']

लेखक सही ढंग से वापस आते हैं और संरचना सही है। इस मॉडल से उद्धृत पाठ कम विश्वसनीय होता है - 0.5B पैरामीटर मॉडल लंबे सूची पर स्ट्रिंग्स को काटता और जोड़ता है - लेकिन फ़ेच परत ने पूरा पृष्ठ वितरित किया, और मॉडल सीमा निर्धारण कारक है, पाइपलाइन नहीं। model कुंजी को एक बड़े स्थानीय मॉडल या एक होस्टेड में स्थानांतरित करें और वही ग्राफ समान लोडर के माध्यम से साफ पाठ उत्पन्न करता है।

संरचित आउटपुट का होना यहाँ का बिंदु है: ग्राफ पार्सड HTML दस्तावेज़ को पढ़ता है जो दूरस्थ ब्राउज़र ने रेंडर किया, न कि कच्चा मार्कअप जो एक साधारण HTTP क्लाइंट को प्राप्त होता। format को json पर सेट करना मॉडल से आउटपुट के लिए JSON इंटरचेंज प्रारूप के अनुरूप पूछता है, जो परिणाम को सीधे उपस्पष्ट करने योग्य बनाता है, न कि एक स्ट्रिंग जिसे आपको पार्स करना है।

निष्कर्ष

ScrapeGraphAI की फ़ेच परत अधिक कॉन्फ़िगर करने योग्य है जितना कि ट्यूटोरियल सुझाव देते हैं, और कॉन्फ़िगरेशन बिंदु loader_kwargs नहीं है - यह backend स्ट्रिंग है, जो एक विधि नाम तक पहुंचता है। एक उपवर्ग जिसमें एक ascrape_scrapeless विधि क्लाउड ब्राउज़र पर फ़ेचिंग को स्थानांतरित करती है, और fetch_node.ChromiumLoader को एक बार फिर से बंधने से ग्राफ इसका उपयोग करता है।

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

ब्राउज़र नियंत्रण जिस दिशा में जा रहा है उसे एक मानक के रूप में देखने के लिए, WebDriver BiDi विशिष्टता को ट्रैक करना योग्य है। Playwright और Scraping Browser मार्गदर्शिका स्वयं कनेक्शन को अधिक गहराई में कवर करती है, योजना विवरण Scrapeless मूल्य निर्धारण पृष्ठ पर हैं, और सत्र पैरामीटर Scrapeless दस्तावेज़ीकरण में हैं।

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

प्रश्न: क्या मुझे क्लाउड पथ का उपयोग करने के लिए एक ब्राउज़र स्थापित करने की आवश्यकता है?

नहीं। pip install scrapegraphai Playwright क्लाइंट प्रदान करता है, जो कि connect_over_cdp को चाहिए, क्योंकि जो ब्राउज़र संचालित किया जा रहा है वह पहले से ही दूरस्थ रूप से चल रहा है। आपको केवल playwright install chromium की आवश्यकता है यदि आप स्थानीय लोडर को भी चलाना चाहते हैं।

प्रश्न: क्यों मेरा कस्टम लोडर ग्राफ द्वारा नजरअंदाज किया जाता है?
लगभग हमेशा क्योंकि fetch_node.ChromiumLoader को कभी पुन: बाधित नहीं किया गया था। FetchNode नाम द्वारा कक्षा को आयात करता है और उस नाम को कॉल करता है, इसलिए केवल उपक्लासिंग से कुछ भी नहीं बदलता है — नोड मूल कक्षा का निर्माण करना जारी रखता है। ग्राफ बनाने से पहले मॉड्यूल पर विशेषता को पुन: बाधित करें।

Q: क्या मैं उपक्लास के बजाय loader_kwargs का उपयोग कर सकता हूँ?

प्रॉक्सी और ब्राउज़र लॉन्च विकल्पों के लिए, हाँ — loader_kwargs सीधे ChromiumLoader में बहता है। हालाँकि, यह फ़etch को दूरस्थ ब्राउज़र पर पुनर्निर्देशित नहीं कर सकता है, क्योंकि स्टॉक विधि chromium.launch() को कॉल करती है, जो हमेशा एक स्थानीय प्रक्रिया शुरू करती है। गंतव्य को बदलने का मतलब विधि को बदलना है, जिसका मतलब उपक्लास है।

Q: क्या यह SmartScraperGraph के अलावा अन्य ग्राफ के साथ काम करता है?

हाँ। पुनः बाधन नोड स्तर पर होता है, और FetchNode अन्य ग्राफ प्रकारों के लिए भी प्रवेश नोड है, इसलिए कोई भी ग्राफ जो एक URL को फ़etch करता है एक बार विशेषता बंधी होने के बाद वही लोडर के माध्यम से जाता है।

Q: sessionTTL क्या नियंत्रित करता है?

कितनी देर तक दूरस्थ ब्राउज़र सत्र खुला रहता है, सेकंड में। इसे आराम से एकल फ़etch लेने के समय के ऊपर सेट करें; सत्र तब बंद हो जाता है जब कनेक्शन समाप्त होता है या विंडो समाप्त होती है, जो भी पहले होता है।

Q: क्या मैं फ़etch के दौरान कुकीज़ या लॉग-इन सत्र को बनाए रख सकता हूँ?

storage_state पहले से ही FetchNode द्वारा पास किया गया है और यह उपक्लास कंस्ट्रक्टर तक बिना किसी बदलाव के पहुँचता है, इसलिए मानक Playwright स्टोरेज-स्टेट फ़ाइल काम करती है। इसे दूरस्थ ब्राउज़र पर संदर्भ बनाते समय लागू करें न कि लॉन्च पर, क्योंकि दूरस्थ ब्राउज़र आपके कोड द्वारा लॉन्च नहीं किया गया है।

Q: क्या 0.5B स्थानीय मॉडल असली निष्कर्षण के लिए पर्याप्त है?

संक्षिप्त पृष्ठों के लिए जिनकी आकृति सरल है, यह उपयोगी संरचना उत्पन्न करता है, जैसा कि ऊपर है। लंबे पृष्ठ और_nested схемाएँ_ वे हैं जहाँ यह गिरता है — पाठ काटा जाता है और क्षेत्रों को मर्ज किया जाता है। एक छोटे स्थानीय मॉडल को फ़etch पर सस्ते तरीके से आवर्ती बनाने के लिए एक तरीके के रूप में मानें, फिर उत्पादन चलाने के लिए model कुंजी को स्विच करें।