लामा वेब स्क्रेपिंग: क्यों रेंडरिंग डेटा को निर्धारित करता है

TL;DR:

• "निष्कर्ष निकाल नहीं सकता" और "साफ़ निष्कर्ष निकालता है" के बीच का फासला एक रेंडर कॉल है, और यह गाइड इसे बिल्कुल सही मापता है। केवल GET पर एक जावास्क्रिप्ट-मात्र उत्पाद सूची एक अन-रेंडर्ड टेम्पलेट प्लेसहोल्डर लौटाता है; Scrapeless यूनिवर्सल स्क्रैपिंग एपीआई के माध्यम से js_render के साथ वही URL 13 असली उत्पाद स्पैन लौटाता है, और ल्लामा ने उन सभी 12 असली उत्पादों को सही तरीके से निकाला।
• ल्लामा 4 वर्तमान सस्ता स्तर है, ल्लामा 3 नहीं। meta-llama/llama-4-scout लाइव ओपनराउटर कैटलॉग में सबसे सस्ता वर्तमान पीढ़ी का ल्लामा है - यह ल्लामा 3.1 नाम से अलग और नया परिवार है जिसका उपयोग अधिकांश वर्तमान ट्यूटोरियल्स अभी भी कर रहे हैं।
• मॉडल ने अपनी ओर से एक टूटी हुई टेम्पलेट पंक्ति को चुपचाप फ़िल्टर किया। रेंडर की गई पृष्ठ पर वास्तव में 13 product-name स्पैन होते हैं; एक एक अन-हाइड्रेटेड ${product.name} प्लेसहोल्डर है, और ल्लामा की निष्कर्ष ने ठीक 12 असली उत्पाद लौटाए, बिना बताए नकली को छोड़ते हुए।
• यह क्लाउड पथ है, लोकल नहीं। इस साइट पर एक अलग गाइड, Web Scraping with LLaMA 3, लोकल के जरिए ल्लामा चलाने को कवर करता है; यह गाइड इसके बजाय एक होस्टेड API के माध्यम से ल्लामा 4 चलाता है।
• अभी तक कोई मूल ल्लामा एपीआई कुंजी नहीं? एक समान अनुरोध ओपनरॉटर के माध्यम से चलता है। इस गाइड ने meta-llama/llama-4-scout पर इसे लाइव निष्पादित किया और कैप्चर किया गया आउटपुट दिखाया।
• फ़ेच साइड पर शुरू करने के लिए स्वतंत्र। app.scrapeless.com पर अपनी Scrapeless API कुंजी बनाएं।

क्या ल्लामा वेबसाइटों से स्क्रेप कर सकता है?

एक होस्टेड ल्लामा अंत बिंदु पाठ पढ़ता है और फ़िल्ड्स लौटाता है; यह पृष्ठ नहीं लाता, उनकी जावास्क्रिप्ट का निष्पादन नहीं करता, या सत्र नहीं रखता। यह सत्य है चाहे मॉडल ओलामा के माध्यम से स्थानीय रूप से चले या क्लाउड एपीआई के माध्यम से - मॉडल वेट्स HTTP के काम करने के तरीके में कुछ नहीं बदलते। स्थानीय और क्लाउड पथ के बीच का अंतर केवल यह है कि अनुमान कहाँ होता है।

Web Scraping with LLaMA 3, जो पहले से इस साइट पर है, स्थानीय मार्ग को कवर करता है: llama3.1:8b ओलामा के माध्यम से, उत्पाद पृष्ठों के खिलाफ सeleniium के साथ। यह गाइड दूसरी आधी को कवर करता है - एक होस्टेड ल्लामा 4 मॉडल जो एक एपीआई के माध्यम से पहुँचा जाता है, बिना किसी स्थानीय मॉडल डाउनलोड और किसी GPU की आवश्यकता के, एक अलग डेमो लक्ष्य पर जो विशेष रूप से यह साबित करने के लिए चुना गया है कि फ़ेच लेयर क्यों महत्वपूर्ण है। व्यापक श्रेणी के प्रश्न के लिए, LLM स्क्रैपर व्याख्याता सामान्य रूप से LLM-as-parser टूलिंग को कवर करता है।

स्थापित करें

openai ओपनराउटर पथ को कवर करता है (ल्लामा वहाँ एक OpenAI संगत सतह के पीछे परोसा जाता है), और requests फ़ेच लेयर को कवर करता है:

pip install "llama-api-client==0.6.0" "openai==2.48.0" requests

कॉन्फ़िगर करें

export LLAMA_API_KEY="your_llama_api_key"
export SCRAPELESS_API_KEY="sk_your_scrapeless_key"

एक पृष्ठ प्राप्त करें जिसे ल्लामा वास्तव में पढ़ सकता है

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

# fetch_rendered.py — साधारण GET बनाम सर्वर-साइड रेंडरिंग, वही URL
import os

import requests

URL = "https://www.scrapingcourse.com/javascript-rendering"
MARKER = 'class="product-name"'

plain = requests.get(URL, timeout=60).text
print(f"plain GET: {len(plain):,} अक्षर | उत्पाद-नाम स्पैन: {plain.count(MARKER)}")

resp = requests.post(
    "https://api.scrapeless.com/api/v2/unlocker/request",
    headers={
        "Content-Type": "application/json",
        "x-api-token": os.environ["SCRAPELESS_API_KEY"],
    },
    json={
        "actor": "unlocker.webunlocker",
        "input": {"url": URL, "method": "GET", "js_render": True},
    },
    timeout=120,
)
resp.raise_for_status()
rendered = resp.json().get("data", "")
print(f"rendered:  {len(rendered):,} अक्षर | उत्पाद-नाम स्पैन: {rendered.count(MARKER)}")

with open("page.html", "w", encoding="utf-8") as f:
    f.write(rendered)

रन product-name spans: 1 को सामान्य फेच के लिए प्रिंट करता है — वह एकल हिट एक अन-निष्पादित <span class="product-name">${product.name}</span> टेम्पलेट है, वास्तविक डेटा नहीं — और product-name spans: 13 के लिए रेंडर की गई। दोनों के बीच का अंतर ठीक उसी दस्तावेज़ जीवनचक्र को परिभाषित करता है जिसे HTML स्क्रिप्टिंग विशिष्टता कहती है: ऐसा सामग्री जो केवल तब मौजूद होती है जब स्क्रिप्ट DOM के खिलाफ चलती है। रेंडरिंग और प्रॉक्सी राउटिंग सर्वर-साइड होती है उसी एक POST में — यूनिवर्सल स्क्रैपिंग एपीआई फेच लेयर है, और page.html अब कुछ ऐसा है जिसे एक मॉडल निकाल सकता है।

बुनियादी कार्यान्वयन: लामा को extractor के रूप में

मेटा की आधिकारिक लामा एपीआई response_format={"type": "json_schema", "json_schema": {...}} के माध्यम से संरचित आउटपुट लेती है, जैसा कि मेटा की लामा एपीआई पायथन क्लाइंट रेपोजिटरी पर भेजे गए SDK के अनुसार — इस अंत बिंदु पर कोई निर्विवाद json_object मोड नहीं है, केवल स्कीमा-निर्देशित आउटपुट है। वर्तमान ओपनराउटर कैटलॉग meta-llama/llama-4-scout को सबसे सस्ता लामा 4-पीढ़ी मॉडल बताता है; मेटा की अपनी मूल एपीआई पर समकक्ष मॉडल आईडी पूर्णरूप में Llama-4-Scout-17B-16E-Instruct-FP8 है।

नोट: इस ब्लॉक को एक LLAMA_API_KEY की आवश्यकता है जिसमें क्रेडिट हो — यह एकमात्र पूर्वापेक्षा है जिस पर यह गाइड भरोसा नहीं करता। अगला अनुभाग ओपनराउटर के माध्यम से समान निष्कर्षण लाइव चलाता है, जिसमें कैप्चर किया गया आउटपुट होता है।

# extract_llama.py — मूल लामा एपीआई निष्कर्षण (LLAMA_API_KEY की आवश्यकता है)
import json
import os

from llama_api_client import LlamaAPIClient

client = LlamaAPIClient(api_key=os.environ["LLAMA_API_KEY"])

page_html = open("page.html", encoding="utf-8").read()

response = client.chat.completions.create(
    model="Llama-4-Scout-17B-16E-Instruct-FP8",
    max_completion_tokens=2000,
    response_format={
        "type": "json_schema",
        "json_schema": {
            "name": "Products",
            "schema": {
                "type": "object",
                "properties": {
                    "products": {
                        "type": "array",
                        "items": {
                            "type": "object",
                            "properties": {"name": {"type": "string"}, "price_usd": {"type": "number"}},
                            "required": ["name", "price_usd"],
                        },
                    }
                },
                "required": ["products"],
            },
        },
    },
    messages=[
        {"role": "system", "content": "इस पृष्ठ से हर वास्तविक उत्पाद को निकालें। किसी भी अन-rendered टेम्पलेट प्लेसहोल्डर को नजरअंदाज करें।"},
        {"role": "user", "content": page_html},
    ],
)

data = json.loads(response.completion_message.content.text)
print(f"निकाले गए {len(data['products'])} उत्पाद")

उत्तर आकृति का ध्यान रखें: मेटा की मूल क्लाइंट संदेश को response.completion_message.content.text के तहत लौटाता है, न कि choices[0].message.content पथ जिसे ओपनएआई-संगत क्लाइंट्स उपयोग करते हैं।

क्या कोई मूल कुंजी नहीं है? इसे ओपनराउटर के माध्यम से चलाएं

ओपनराउटर लामा को उसी ओपनएआई-संगत चैट-पूर्णता सतह के पीछे सेवा करता है जैसे इस श्रृंखला के अन्य मॉडल। यही संस्करण है जिसे इस गाइड ने वास्तविकता में चलाया, एक ही आत्म-निहित स्क्रिप्ट में फेच और निष्कर्षण:

# extract_openrouter.py — वही निष्कर्षण, ओपनराउटर के माध्यम से निष्पादित
import json
import os

import requests
from openai import OpenAI

URL = "https://www.scrapingcourse.com/javascript-rendering"

resp = requests.post(
    "https://api.scrapeless.com/api/v2/unlocker/request",
    headers={
        "Content-Type": "application/json",
        "x-api-token": os.environ["SCRAPELESS_API_KEY"],
    },
    json={"actor": "unlocker.webunlocker", "input": {"url": URL, "method": "GET", "js_render": True}},
    timeout=120,
)
resp.raise_for_status()
page_html = resp.json().get("data", "")

client = OpenAI(base_url="https://openrouter.ai/api/v1", api_key=os.environ["OPENROUTER_API_KEY"])

completion = client.chat.completions.create(
    model="meta-llama/llama-4-scout",
    temperature=0,
    max_tokens=2000,
    response_format={"type": "json_object"},
    messages=[
        {
            "role": "system",
            "content": 'हर उत्पाद को निकालें। केवल JSON के साथ उत्तर दें: {"products":[{"name":str,"price_usd":number}]}।',
        },
        {"role": "user", "content": page_html},
    ],
)

data = json.loads(completion.choices[0].message.content)
print(f"रेंडर की गई पृष्ठ से निकाले गए {len(data['products'])} उत्पाद")
for row in data["products"]:
    print(json.dumps(row, ensure_ascii=False))

लाइव रन ने ठीक 12 वास्तविक उत्पाद निकाले, प्लेसहोल्डर में से कोई भी नहीं:

रेंडर की गई पृष्ठ से निकाले गए 12 उत्पाद

{"name": "Chaz Kangeroo Hoodie", "price_usd": 52}
{"name": "Teton Pullover Hoodie", "price_usd": 70}
दोनों समान फेच-फिर-निकालने वाली आर्किटेक्चर के साथ काम करते हैं। स्थानीय रूप से, ओलामा के माध्यम से, प्रति-टोकन लागत से बचता है लेकिन एक GPU-सक्षम होस्ट और एक मॉडल डाउनलोड की आवश्यकता होती है; इस गाइड का क्लाउड मार्ग स्थानीय हार्डवेयर की आवश्यकता नहीं है लेकिन प्रति टोकन बिल करता है। साथी पोस्ट LLaMA 3 के साथ वेब स्क्रैपिंग स्थानीय मार्ग को विस्तार से कवर करती है।

प्रश्न: मॉडल ने रेंडर की गई पृष्ठ पर एक उत्पाद क्यों छोड़ा?

क्योंकि यह एक असली उत्पाद नहीं था। इस गाइड के लाइव रन में रेंडर की गई HTML में 13 product-name स्पैन थे, लेकिन एक ${product.name} टेम्पलेट प्लेसहोल्डर था जो पृष्ठ के क्लाइंट-साइड फ्रेमवर्क से बचे हुए थे - मॉडल ने सही ढंग से इसे निकाले गए 12 में से बाहर कर दिया।

प्रश्न: क्या लामा के साथ स्क्रैप करना कानूनी है?

निकासी परत न तो क्लाउड के लिए और न ही स्थानीय मार्ग के लिए संग्रह नियमों को बदलती है। केवल सार्वजनिक पृष्ठों को प्राप्त करें, साइट की शर्तों और रोबोट्स बहिष्करण प्रोटोकॉल द्वारा मानकीकृत रोबोट्स निर्देशों का सम्मान करें, मात्रा को सीमित रखें, और लागू कानून के तहत किसी भी व्यक्तिगत डेटा का प्रबंधन करें।