क्रूएआई + स्क्रेपलेस: एक स्थानीय LLM के साथ एक मल्टी-एजेंट स्क्रेपिंग क्रू चलाएँ

TL;DR:

• यह एक वास्तविक मल्टी-एजेंट कार्यप्रवाह है। तीन CrewAI एजेंट एक लाइव पृष्ठ लाते हैं, संरचित रिकॉर्ड निकालते हैं, और एक अनुक्रमिक कार्य हैंडओफ़ के माध्यम से परिणामों को मान्य करते हैं।
• केवल फेच करने वाले को वेब एक्सेस मिलता है। वेब पृष्ठ फेचर को Scrapeless MCP का scrape_markdown टूल मिलता है; एक्स्ट्रेक्टर और वेलिडेटर केवल पिछले कार्य के आउटपुट पर काम करते हैं।
• LLM स्थानीय रूप से चलता है। सभी तीन एजेंट qwen2.5:0.5b का उपयोग करते हैं ओल्लामा के माध्यम से, इसलिए कार्यप्रवाह के लिए कोई क्लाउड LLM API कुंजी की आवश्यकता नहीं है।
• सफल निष्पादन सही निष्कर्ष को साबित नहीं करता है। crew.kickoff() पूर्ण हुआ, लेकिन कैप्चर किया गया वेलिडेटर आउटपुट अपने आप से विरोधाभासी था और इसे अस्वीकृत करना पड़ा।
• उत्पादन मान्यता को निरंतर होना चाहिए। मॉडल आउटपुट को पायथन में पार्स करें, आवश्यक क्षेत्रों को मान्य करें, और निकाले गए मानों की तुलना मूल MCP प्रतिक्रिया के साथ करें।
• शुरू करने के लिए स्वतंत्र। नए Scrapeless खाते मुफ्त स्क्रैपिंग ब्राउज़र रनटाइम के साथ आते हैं — app.scrapeless.com पर साइन अप करें।

परिचय: पूरा दल अभी तक एक विश्वसनीय पाइपलाइन नहीं है

एक CrewAI एजेंट Scrapeless MCP टूल से जुड़ा हुआ एक लाइव पृष्ठ लाने में सक्षम है। एक CrewAI दल एक अलग दावा है: दो या दो से अधिक एजेंट जिनकी अलग जिम्मेदारियाँ हैं, एक-दूसरे को कार्य सौंपना चाहिए और crew.kickoff() के परिणाम के साथ खत्म होना चाहिए।

यह गाइड उस दूसरे कार्यप्रवाह को बनाता है।

आप एक तीन-एजेंट दल बनाएंगे जो:

1. Scrapeless MCP सर्वर के माध्यम से एक लाइव पृष्ठ लाता है।
2. लौटाए गए मार्कडाउन से संरचित उद्धरण रिकॉर्ड को निकालता है।
3. कार्यप्रवाह से बाहर जाने से पहले उन रिकॉर्डों को मान्य करता है।

तीनों एजेंट एक स्थानीय ओल्लामा मॉडल पर चलते हैं। ओपनएआई, ऐंथ्रोपिक या अन्य क्लाउड LLM कुंजी की आवश्यकता नहीं है। एकमात्र बाहरी प्रमाण पत्र Scrapeless API कुंजी है जो MCP टूल द्वारा उपयोग की जाती है।

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

आप इस दल के साथ क्या कर सकते हैं

कार्यप्रवाह हर एजेंट को एक जिम्मेदारीAssign करता है:

• वेब पृष्ठ फेचर: एक लाइव URL के खिलाफ Scrapeless MCP scrape_markdown टूल कॉल करता है और पृष्ठ सामग्री लौटाता है।
• डेटा एक्स्ट्रेक्शन विशेषज्ञ: लाए गए मार्कडाउन को पढ़ता है और इसे एक JSON एरे में परिवर्तित करता है।
• QA वेलिडेटर: निकाले गए रिकॉर्ड्स के लिए गायब क्षेत्रों की जांच करता है और परिणाम की रिपोर्ट करता है।

CrewAI कार्य आउटपुट को स्पष्ट कार्य संदर्भ के माध्यम से पास करता है। एक्स्ट्रेक्टर फेच कार्य का आउटपुट प्राप्त करता है, और वेलिडेटर एक्स्ट्रेक्शन कार्य का आउटपुट प्राप्त करता है।

तीन एजेंटों के बीच कुछ भी मैन्युअल रूप से कॉपी करने की आवश्यकता नहीं है।

यह एक स्थानीय मॉडल को सीधे एक फेच-और-निकालने वाले पायथन कार्य में वायर करने से भिन्न है। ओल्लामा वेब स्क्रैपिंग गाइड उस सरल पैटर्न को कवर करता है।

यहाँ, CrewAI ने संचालन का स्वामित्व लिया है:

• तीन एजेंट
• तीन स्कोप वाले प्रॉम्प्ट
• तीन अलग-अलग टोकन सीमाएँ
• एक ढाँचा-प्रबंधित अनुक्रमिक हैंडओफ़

एक एजेंट के बजाय दल का उपयोग क्यों करें?

एक स्क्रैपिंग टूल के साथ एकल एजेंट को यह तय करना होगा कि क्या लाना है, पृष्ठ को कैसे व्याख्या करना है, परिणाम को कैसे प्रारूपित करना है, और क्या वह परिणाम स्वीकार्य है।

उन जिम्मेदारियों को अलग-अलग भूमिकाओं में विभाजित करने से आपको कार्यप्रवाह पर स्पष्ट नियंत्रण मिलता है।

प्रत्येक एजेंट को प्राप्त होता है:

• एक संकीर्ण लक्ष्य
• एक केंद्रित कार्य
• इसका अपना आउटपुट सीमा
• केवल उसे आवश्यक टूल्स तक पहुँच

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

यह विभाजन आपको स्पष्ट निरीक्षण अंक भी देता है। उत्पादन पाइपलाइन में, आप प्रत्येक कार्य के बाद आउटपुट को सहेज सकते हैं या मान्य कर सकते हैं और पहचान सकते हैं कि क्या कोई विफलता पुनः प्राप्ति, निकासी, या मान्यता के दौरान हुई।

Scrapeless MCP सर्वर का उपयोग क्यों करें?

मॉडल संदर्भ प्रोटोकॉल विनिर्देश एक मानक तरीके को परिभाषित करता है जिससे एक AI ग्राहक एक सर्वर द्वारा प्रस्तुत टूल को खोजने और सक्रिय करने में सक्षम होता है।

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

Scrapeless MCP सर्वर अवलोकन व्यापक टूल परिवार को समझाता है, जिसमें पृष्ठ पुनर्प्राप्ति, खोज और ब्राउज़र-नियंत्रण उपकरण शामिल हैं।

इस कार्यप्रवाह के लिए, दल को केवल एक उपकरण की आवश्यकता है:

scrape_markdown

यह लक्षित पृष्ठ को पुनः प्राप्त करता है और सामग्री को एक प्रारूप में लौटाता है जिसे डाउनस्ट्रीम निष्कर्षण एजेंट पढ़ सकता है।

आप नवीनतम सर्वर कनेक्शन विवरण और उपकरण तर्कों के लिए Scrapeless डेवलपर दस्तावेज़ की जांच कर सकते हैं।

पूर्व आवश्यकताएँ

क्रू चलाने से पहले, आपको निम्नलिखित की आवश्यकता है:

• Python 3.10 या बाद का
• CrewAI और CrewAI Tools
• एक Scrapeless API कुंजी
• Ollama स्थानीय रूप से स्थापित और चल रहा हो
• Ollama में qwen2.5:0.5b मॉडल डाउनलोड किया गया हो

आपको OPENAI_API_KEY, ANTHROPIC_API_KEY, या किसी अन्य होस्टेड LLM क्रेडेंशियल की आवश्यकता नहीं है। इस उदाहरण में हर CrewAI LLM ऑब्जेक्ट स्थानीय Ollama सर्वर की ओर इशारा करता है।

चरण 1 — CrewAI और MCP समर्थन स्थापित करें

सत्यापित उदाहरण स्थिर CrewAI पैकेज का उपयोग करता है:

pip install "crewai==1.15.4" "crewai-tools[mcp]==1.15.4"

[mcp] अतिरिक्त MCPServerAdapter द्वारा आवश्यक MCP क्लाइंट निर्भरता को स्थापित करता है। यह एडाप्टर MCP उपकरण परिभाषाओं को उस उपकरणों में परिवर्तित करता है जिन्हें CrewAI एजेंट कॉल कर सकते हैं।

चरण 2 — स्थानीय Ollama मॉडल कॉन्फ़िगर करें

इस उदाहरण में उपयोग किए गए मॉडल को खींचें:

ollama pull qwen2.5:0.5b

यह पुष्टि करें कि Ollama इसे देख सकता है:

ollama list

Ollama सामान्यतः अपनी स्थानीय API यह परिपूर्णता दिखाता है:

http://localhost:11434

यदि Ollama स्थापित है लेकिन क्रू कनेक्ट नहीं कर सकता, तो Python स्क्रिप्ट लॉन्च करने से पहले पुष्टि करें कि Ollama सेवा चल रही है।

इसके बाद, अपने शेल में Scrapeless API कुंजी कॉन्फ़िगर करें:

export SCRAPELESS_API_KEY="your_api_key_here"

एक पर्यावरण परिवर्तनशीलता से कुंजी पढ़ना इसे Python स्रोत फ़ाइल से बाहर रखता है।

चरण 3 — CrewAI को Ollama की ओर इंगीत करें

हर एजेंट के लिए एक अलग LLM कॉन्फ़िगरेशन बनाएँ:

from crewai import LLM

fetch_llm = LLM(
    model="ollama/qwen2.5:0.5b",
    base_url="http://localhost:11434",
    max_tokens=180,
    temperature=0,
)

extract_llm = LLM(
    model="ollama/qwen2.5:0.5b",
    base_url="http://localhost:11434",
    max_tokens=100,
    temperature=0,
)

validate_llm = LLM(
    model="ollama/qwen2.5:0.5b",
    base_url="http://localhost:11434",
    max_tokens=70,
    temperature=0,
)

तीनों कॉन्फ़िगरेशन एक ही मॉडल का उपयोग करते हैं, लेकिन उनके आउटपुट सीमाएं उनके जिम्मेदारियों को दर्शाती हैं:

• समेटने वाले पृष्ठ सामग्री लौटाने के लिए अधिक जगह रखता है।
• निष्कर्ष निकालने वाले के पास एक छोटे JSON एरे के लिए पर्याप्त टोकन की आवश्यकता होती है।
• मान्यता देने वाले को केवल एक संक्षिप्त रिपोर्ट तैयार करने की आवश्यकता है।

temperature=0 सेट करना आउटपुट भिन्नता को कम करता है। यह निश्चित या सही परिणामों की गारंटी नहीं देता है, विशेषकर जब एक छोटे स्थानीय मॉडल के साथ हो।

CPU-केवल स्थानीय अनुमान में, max_tokens भी एक महत्वपूर्ण रनटाइम नियंत्रण होता है। निम्न सीमाएँ एक एजेंट को अनावश्यक रूप से लंबे उत्तर उत्पन्न करने से रोकती हैं, भले ही मॉडल का आकार, हार्डवेयर, संदर्भ की लंबाई और एजेंट चालों की संख्या भी निष्पादन समय को प्रभावित करते हैं।

चरण 4 — CrewAI को Scrapeless MCP सर्वर से कनेक्ट करें

MCPServerAdapter आयात करें और दूरस्थ MCP कनेक्शन को परिभाषित करें:

import os
from crewai_tools import MCPServerAdapter

server_params = {
    "url": "https://api.scrapeless.com/mcp",
    "transport": "streamable-http",
    "headers": {
        "x-api-token": os.environ["SCRAPELESS_API_KEY"]
    },
}

कॉन्फ़िगरेशन में तीन महत्वपूर्ण मान होते हैं:

• url Scrapeless MCP अंत बिंदु की ओर इशारा करता है।
• transport क्लाइंट को स्ट्रीम करने योग्य HTTP का उपयोग करने के लिए बताता है।
• x-api-token आपकी Scrapeless कुंजी के साथ अनुरोध की प्रमाणीकरण करता है।

कुंजी तक पहुँचने के लिए:

os.environ["SCRAPELESS_API_KEY"]

यदि पर्यावरण परिवर्तनशीलता गायब है, तो Python तुरंत बंद हो जाएगा, जो बिना मान्य उपकरण क्रेडेंशियल्स के क्रू को मौन रूप से लॉन्च करने से बेहतर है।

चरण 5 — उपलब्ध MCP उपकरण को सत्यापित करें

पूर्ण क्रू बनाने से पहले, सत्यापित करें कि एडाप्टर अनुरोधित उपकरण को खोज सकता है:

with MCPServerAdapter(server_params, "scrape_markdown") as tools:
    print([tool.name for tool in tools])

सत्यापन चलने से मिला:

['scrape_markdown']

यह पुष्टि करता है कि:

• MCP क्लाइंट सर्वर तक पहुँचा।
• सर्वर ने प्रमाणीकरण हेडर को स्वीकार किया।
• अनुरोधित उपकरण CrewAI के लिए उपलब्ध था।

यह साबित नहीं करता कि हर भविष्य का पृष्ठ अनुरोध अपेक्षित डेटा को समाहित करेगा, या कि एक डाउनस्ट्रीम मॉडल प्रतिक्रिया को सही रूप से व्याख्या करेगा।

यहाँ प्रयुक्त MCP उपकरण सतह

MCPServerAdapter सर्वर उपकरणों को CrewAI एजेंटों को उजागर कर सकता है। "scrape_markdown" पारित करने से इस कार्यप्रवाह को उस एक उपकरण तक सीमित कर देता है जिसकी इसे आवश्यकता है:

with MCPServerAdapter(server_params, "scrape_markdown") as tools:
    ...

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

अनुमति सीमा सरल है:

केवल फ़ेचर एक लाइव वेब अनुरोध कर सकता है।

आप इसे वास्तव में कैसे उपयोग करते हैं: क्रू का निर्माण और संचालन करें

तीन एजेंट भूमिकाएँ परिभाषित करें

हर चरण के लिए एक एजेंट बनाएं:

from crewai import Agent

fetcher = Agent(
    role="वेब पृष्ठ फ़ेचर",
    goal=(
        "scrape_markdown टूल का उपयोग करके दिए गए सटीक URL को फ़ेच करें "
        "और उसकी कच्ची आउटपुट वापस करें।"
    ),
    backstory=(
        "वेब ब्राउज़ नहीं कर सकने वाले साथियों के लिए सार्वजनिक वेब पृष्ठों को "
        "पुनः प्राप्त करता है।"
    ),
    tools=tools,
    llm=fetch_llm,
    max_iter=2,
)

extractor = Agent(
    role="डेटा निष्कर्षण विशेषज्ञ",
    goal=(
        "प्राप्त पृष्ठ मार्कडाउन को एक साफ संरचित "
        "रिकॉर्ड में परिवर्तित करें जिसमें हर उद्धरण और उसके लेखक का नाम हो।"
    ),
    backstory=(
        "कच्चे scraped मार्कडाउन को पढ़ता है और ठीक से "
        "उन क्षेत्रों को निकालता है जिनकी एक डेटाबेस को जरूरत होती है।"
    ),
    llm=extract_llm,
    max_iter=2,
)

validator = Agent(
    role="QA validator",
    goal="निष्कर्षित उद्धरण रिकॉर्ड की पूर्णता की जाँच करें इससे पहले कि वे भेजें।",
    backstory=(
        "अपूर्ण या गलतफहमी वाले रिकॉर्ड को अस्वीकार करता है और "
        "ठीक से बताते हैं कि उसने क्या जाँचा।"
    ),
    llm=validate_llm,
    max_iter=2,
)

केवल fetcher को tools=tools मिलता है।

extractor और validator को कार्य संदर्भ से काम करना चाहिए। वे लक्ष्य पृष्ठ को स्वतंत्र रूप से ब्राउज़ नहीं कर सकते या कोई अन्य MCP अनुरोध नहीं कर सकते।

max_iter=2 सेट करने का कारण क्या है?

max_iter उस संख्या को सीमित करता है जो एक एजेंट एक कार्य के दौरान तर्क और क्रिया चक्रों का प्रदर्शन कर सकता है।

2 का मान fetcher को एक टूल कॉल करने और फिर एक अंतिम उत्तर उत्पन्न करने के लिए पर्याप्त स्थान देता है। यह छोटे मॉडल को अत्यधिक संख्या में आंतरिक लूप के माध्यम से जारी रखने से भी रोकता है।

यह सीमा एक नियंत्रण तंत्र है, न कि सत्यता की गारंटी। यदि एक एजेंट गलत JSON उत्पन्न करता है या खाली क्षेत्रों को स्वीकार करता है, तो पुनरावृत्ति सीमा तक पहुंचना सफलतापूर्वक उस आउटपुट को मान्य नहीं बनाता है।

केवल फ़ेचर के साथ MCP टूल संलग्न करें

Fetcher की भूमिका संकीर्ण रूप से परिभाषित है:

1. लक्षित URL प्राप्त करें।
2. scrape_markdown कॉल करें।
3. अतिरिक्त टिप्पणी के बिना टूल आउटपुट लौटाएं।

Extractor कभी भी ब्राउज़िंग निर्देश के रूप में लाइव URL प्राप्त नहीं करता है। यह फ़ेचर द्वारा लौटाई गई सामग्री को पढ़ता है।

Validator कभी भी MCP टूल प्राप्त नहीं करता है। यह केवल extractor के आउटपुट को पढ़ता है।

यह अलगाव डेटा प्रवाह को समझना और ऑडिट करना आसान बनाता है।

अनुक्रमिक कार्य संदर्भ को तार करें

CrewAI कार्य पहले के कार्यों का संदर्भ context तर्क के माध्यम से कर सकते हैं:

extract_task = Task(
    ...,
    context=[fetch_task],
)

validate_task = Task(
    ...,
    context=[extract_task],
)

इसलिए हैंडऑफ़ है:

fetch_task → extract_task → validate_task

Extractor fetch कार्य का अंतिम उत्तर प्राप्त करता है। Validator extraction कार्य का अंतिम उत्तर प्राप्त करता है।

कोई मैनुअल स्ट्रिंग-पPassing की आवश्यकता नहीं है।

crew.kickoff() के साथ क्रू चलाएं

नीचे पूरा स्क्रिप्ट है:

import os

from crewai import Agent, Crew, LLM, Process, Task
from crewai_tools import MCPServerAdapter


TARGET_URL = "https://quotes.toscrape.com/tag/obvious/"

server_params = {
    "url": "https://api.scrapeless.com/mcp",
    "transport": "streamable-http",
    "headers": {
        "x-api-token": os.environ["SCRAPELESS_API_KEY"]
    },
}

fetch_llm = LLM(
    model="ollama/qwen2.5:0.5b",
    base_url="http://localhost:11434",
    max_tokens=180,
    temperature=0,
)

extract_llm = LLM(
    model="ollama/qwen2.5:0.5b",
    base_url="http://localhost:11434",
    max_tokens=100,
    temperature=0,
)

validate_llm = LLM(
    model="ollama/qwen2.5:0.5b",
    base_url="http://localhost:11434",
    max_tokens=70,
    temperature=0,
)

with MCPServerAdapter(server_params, "scrape_markdown") as tools:
    fetcher = Agent(
        role="वेब पृष्ठ फ़ेचर",
        goal=(
            f"URL {TARGET_URL} का फ़ेच करें "
            "scrape_markdown टूल का उपयोग करते हुए और उसकी कच्ची आउटपुट वापस करें।"
        ),
        backstory=(
            "वेब ब्राउज़ नहीं कर सकने वाले साथियों के लिए सार्वजनिक वेब पृष्ठों को "
            "पुनः प्राप्त करता है।"
        ),
        tools=tools,
        llm=fetch_llm,
        max_iter=2,
    )

    extractor = Agent(
        role="डेटा निष्कर्षण विशेषज्ञ",
        goal=(
            "प्राप्त पृष्ठ मार्कडाउन को एक साफ संरचित "
            "रिकॉर्ड में परिवर्तित करें जिसमें हर उद्धरण और उसके लेखक का नाम हो।"
        ),
        backstory=(
            "कच्चे scraped मार्कडाउन को पढ़ता है और ठीक से "
            "उन क्षेत्रों को निकालता है जिनकी एक डेटाबेस को जरूरत होती है।"
        ),
        llm=extract_llm,
        max_iter=2,
    )

    validator = Agent(
        role="QA validator",
        goal=(
            "निष्कर्षित उद्धरण रिकॉर्ड की पूर्णता "
            "की जाँच करें इससे पहले कि वे भेजें।"
        ),
        backstory=(
            "अपूर्ण या गलतफहमी वाले रिकॉर्ड को अस्वीकार करता है और "

"रिपोर्ट करता है कि उसने ठीक-ठीक क्या जांचा।"
),
llm=validate_llm,
max_iter=2,
)

fetch_task = Task(
    description=(
        f"URL='{TARGET_URL}' के साथ scrape_markdown टूल कॉल करें। "
        "टूल आउटपुट को बिल्कुल आपके अंतिम उत्तर के रूप में लौटाएं, "
        "इसके आगे या पीछे कोई टिप्पणी न हो।"
    ),
    expected_output=(
        "scrape_markdown टूल द्वारा लौटाया गया कच्चा मार्कडाउन।"
    ),
    agent=fetcher,
)

extract_task = Task(
    description=(
        "आपको संदर्भ के रूप में एक उद्धरण पृष्ठ का कच्चा मार्कडाउन दिया गया है। "
        "पृष्ठ पर हर उद्धरण ढूंढें। प्रत्येक के लिए, "
        'एक JSON ऑब्जेक्ट आउटपुट करें जिसमें "text" (उद्धरण) '
        'और "author" (जिस व्यक्ति का नाम "द्वारा" है) के कुंजियाँ हैं। लौटाएँ '
        "केवल इन ऑब्जेक्ट्स का एक JSON एरे, और कुछ नहीं।"
    ),
    expected_output=(
        'ऐसा JSON एरे जैसे [{"text": "...", "author": "..."}] '
        "जो हर मिले उद्धरण के लिए एक प्रविष्टि के साथ हो।"
    ),
    agent=extractor,
    context=[fetch_task],
)

validate_task = Task(
    description=(
        "आपको संदर्भ के रूप में उद्धरण रिकॉर्ड का एक JSON एरे दिया गया है। "
        "जांचें कि एरे में कम से कम एक प्रविष्टि हो और कि "
        "हर प्रविष्टि में एक नॉन-एंप्टी टेक्स्ट और लेखक क्षेत्र हो। "
        "कुल रिकॉर्ड की संख्या, लेखक की सूची और "
        "एक पूर्णता बयान रिपोर्ट करें।"
    ),
    expected_output=(
        "एक संक्षिप्त रिपोर्ट: रिकॉर्ड की संख्या, लेखक की सूची, "
        "पूर्णता का बयान।"
    ),
    agent=validator,
    context=[extract_task],
)

crew = Crew(
    agents=[fetcher, extractor, validator],
    tasks=[fetch_task, extract_task, validate_task],
    process=Process.sequential,
)

result = crew.kickoff()

print(result)

स्क्रिप्ट `crew.kickoff()` को MCP एडेप्टर संदर्भ के अंदर कॉल करती है। यह फेचर के कार्य करते समय दूरस्थ टूल कनेक्शन उपलब्ध रखता है।

तीनों कार्य समाप्त होने के बाद, स्क्रिप्ट अंतिम `CrewOutput` का प्रिंट करती है।

## आपको क्या मिलता है

सत्यापन चलाने ने तीन अलग-अलग स्तरों पर साक्ष्य उत्पन्न किया:

| स्तर | कैप्चर किया गया साक्ष्य | समर्थित निष्कर्ष |
|---|---|---|
| MCP कनेक्शन | `['scrape_markdown']` | CrewAI ने अनुरोधित MCP उपकरण का पता लगाया |
| क्रू निष्पादन | `crew.kickoff()` बिना उठाए लौटा | अनुक्रमित कार्यप्रवाह अंतिम कार्य तक पहुँच गया |
| डेटा गुणवत्ता | अंतिम उत्तर ने अपने आप से विरोधाभास किया | परिणामस्वरूप रिकॉर्ड को अस्वीकार किया जाना चाहिए |

अंतिम सत्यापनकर्ता आउटपुट था:

```text
0  ["", "", ""] पूर्ण। JSON एरे में एक प्रविष्टि है और सभी फ़ील्ड खाली नहीं हैं। इसलिए, यह पूर्णता के लिए मानदंडों को पूरा करता है।

यह आउटपुट आंतरिक रूप से असंगत है।

यह रिपोर्ट करता है:

• गिनती 0
• तीन пуст स्ट्रिंग्स
• एक कथित रूप से पूर्ण प्रविष्टि
• एक बयान कि सभी फ़ील्ड खाली नहीं हैं

ये सभी बयान एक ही समय में सही नहीं हो सकते।

प्रक्रिया पूर्ण हुई, लेकिन डेटा ने एक महत्वपूर्ण गुणवत्ता जांच पास नहीं की।

अंतिम आउटपुट ने मान्यता की विफलता क्यों की

MCP हैंडशेक ने क्या प्रमाणित किया

MCP हैंडशेक ने लौटाया:

['scrape_markdown']

यह साबित करता है कि CrewAI ने Scrapeless MCP सर्वर से कनेक्ट किया और अनुरोधित टूल का पता लगाया।

इसलिए, वेब पृष्ठ फेचर के पास निष्पादन के दौरान एक वास्तविक दूरस्थ टूल उपलब्ध था।

crew.kickoff() ने क्या प्रमाणित किया

crew.kickoff() ने बिना किसी अपवाद के CrewOutput लौटाया।

यह प्रमाणित करता है:

• क्रू सफलतापूर्वक बनाया गया था।
• तीन कार्य स्वीकार किए गए थे।
• अनुक्रमिक संगीनी ने सत्यापनकर्ता कार्य तक पहुँचाया।
• CrewAI ने एक अंतिम परिणाम लौटाया।

यह साबित नहीं करता कि प्राप्त सामग्री ने हर मॉडल हेंडऑफ को सटीक रूप से बचे।

अंतिम उत्तर ने क्या प्रमाणित नहीं किया

लक्षित पृष्ठ में स्पष्ट टैग के तहत एक उद्धरण है:

"धूप के बिना एक दिन, आप जानते हैं, रात जैसा होता है।"
— स्टीव मार्टिन

कैप्चर किया गया अंतिम उत्तर उन मानों को बनाए नहीं रख सका।

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

• फेचर ने MCP प्रतिक्रिया का संक्षेपण या परिवर्तन किया।
• वैकल्पिक ने मार्कडाउन को JSON में परिवर्तित किया।
• सत्यापनकर्ता ने वैकल्पिक के आउटपुट की व्याख्या की।
• एक से अधिक चरणों ने डेटा को बिगाड़ा।

उपलब्ध साक्ष्य केवल एक संकीर्ण निष्कर्ष का समर्थन करता है: क्रू ने अपने अंतिम कार्य तक पहुँचाया, लेकिन सत्यापनकर्ता ने एक परिणाम को स्वीकार किया जो अपने आप से विरोधाभास करता था।

टूल-कॉलिंग क्रू में छोटे स्थानीय मॉडल: ईमानदार परिणाम

परीक्षण किए गए मॉडल में लगभग 494 मिलियन पैरामीटर हैं। यह स्थानीय रूप से चलाने के लिए पर्याप्त छोटा था, और इसने CrewAI कार्यप्रवाह को पूरा करने तक ले गया।

पूर्ण रन ने परीक्षण किए गए होस्ट पर 542 सेकंड बाद कोड 0 के साथ निकासी की।

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

• CrewAI ने तीन एजेंट बनाए।
• फ़ेचर को एक लाइव स्क्रेपलेस MCP उपकरण मिला।
• कार्य संदर्भ ने तीन चरणों को जोड़ा।
• crew.kickoff() पूरा हो गया।
• कोई क्लाउड LLM कुंजी का उपयोग नहीं किया गया।

हालांकि, इस रन ने परिणाम स्वरूप क्षेत्रों पर भरोसा करने का समर्थन नहीं किया। अंतिम आउटपुट में शून्य संख्या, खाली मूल्य और एक सफलता बयान मिला।

एक सब-1B मॉडल ऑर्केस्ट्रेशन का परीक्षण करने के लिए उपयोगी हो सकता है, लेकिन यह रन दिखाता है कि इसे स्वचालित रूप से एक विश्वसनीय संरचित-डेटा निकालने वाले के रूप में नहीं माना जाना चाहिए।

क्रू के बाद निर्धारीकरण सत्यापन जोड़ें

प्राकृतिक-भाषा सत्यापन अभी भी मॉडल आउटपुट है। एक वैलिडेटर एजेंट गलत डेटा को गलत समझ सकता है, खाली मानों को अनदेखा कर सकता है, या एक निष्कर्ष उत्पन्न कर सकता है जो अपनी ही रिपोर्ट के विरोधाभासी हो।

इसलिए उत्पादन सत्यापन को मॉडल कार्यप्रवाह के बाद सामान्य कोड में होना चाहिए।

एक्सट्रैक्टर आउटपुट को पार्स करें

एक्सट्रैक्टर की प्रतिक्रिया को पार्स करने के लिए json.loads का उपयोग करें।

यदि परिणाम को अस्वीकार करें:

• यह मान्य JSON नहीं है।
• शीर्ष स्तर का मान एक एरे नहीं है।
• प्रतिक्रिया में JSON के चारों ओर गद्य शामिल है।
• एरे अप्रत्याशित रूप से खाली है।

आवश्यक क्षेत्रों का सत्यापन करें

हर रिकॉर्ड के लिए, सत्यापित करें कि:

• text मौजूद है।
• author मौजूद है।
• दोनों मान स्ट्रिंग हैं।
• दोनों मान सफेद स्थान को ट्रिम करने के बाद भी गैर-खाली रहते हैं।
• न ही मान एक स्पष्ट प्लेसहोल्डर है।

“सभी क्षेत्रों को पूरा किया गया है” जैसे प्राकृतिक-भाषा के बयान को एक असफल प्रोग्रामेटिक चेक को ओवरराइड करने न दें।

विरोधाभासी गणनाओं को अस्वीकार करें

यदि वैलिडेटर एक गणना की रिपोर्ट करता है, तो इसे वास्तविक JSON एरे की लंबाई के साथ तुलना करें।

एक रिपोर्ट जिसमें एक पूर्ण प्रविष्टि का दावा किया गया है जबकि शून्य की गणना भी रिपोर्ट की गई हो, को तुरंत असफल होना चाहिए।

निकाले गए मानों की तुलना स्रोत के साथ करें

scrape_markdown द्वारा लौटाए गए मूल मार्कडाउन को बनाए रखें।

जैसे उद्धरण और लेखक के नाम की प्रतियों से, सत्यापित करें कि निकाले गए मान स्रोत प्रतिक्रिया में दिखाई देते हैं। यह फर्जी, टुकड़े-टुकड़े हुए, या प्रतिस्थापित सामग्री का पता लगाने में मदद करता है।

मध्यवर्ती कार्य आउटपुट को बनाए रखें

उदाहरण केवल अंतिम क्रू आउटपुट को प्रिंट करता है। डिबगिंग और उत्पादन निगरानी के लिए, हर कार्य से आउटपुट को बनाए रखें।

यह आपको तीन अलग-अलग कलाकृतियों देता है:

1. कच्चा फेच किया गया मार्कडाउन
2. निकाली गई JSON
3. सत्यापन रिपोर्ट

इन आउटपुट्स के उपलब्ध होने पर, आप यह पहचान सकते हैं कि डेटा किस चरण में खो गया, बजाय इसके कि अंतिम उत्तर से अनुमान लगाने के।

आवश्यकतानुसार मॉडल क्षमता बढ़ाएँ

सशक्त सत्यापन खराब परिणामों को अस्वीकार कर सकता है, लेकिन यह स्रोत पाठ को पुनर्स्थापित नहीं कर सकता जिसे मॉडल ने संरक्षित करने में विफल रहा।

यदि एक छोटा मॉडल निकासी या सत्यापन के दौरान बार-बार डेटा खोता है, तो एक बड़ा स्थानीय मॉडल या अधिक सक्षम होस्टेड मॉडल का उपयोग करें। पाइपलाइन को सफल दिखाने के लिए चेक को कमजोर न करें।

निष्कर्ष

एक स्थानीय ओलामा मॉडल पर चलने वाला CrewAI क्रू स्क्रेपलेस MCP सर्वर से कनेक्ट कर सकता है, एक लाइव स्क्रैपिंग टूल को कॉल कर सकता है, तीन एजेंटों के माध्यम से डेटा पास कर सकता है, और बिना क्लाउड LLM कुंजी के crew.kickoff() को पूरा कर सकता है।

यह इंटीग्रेशन का परिणाम है।

पकड़ा गया अंतिम आउटपुट अभी भी इतना गलत था कि उसे अस्वीकार किया जाए: यह एक शून्य गणना और खाली मानों की रिपोर्ट करता था जबकि साथ ही यह दावा करता था कि डेटा पूरा था।

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

उपकरण-कालिंग क्रू बनाने के लिए तैयार?

एक फ्री स्क्रेपलेस अकाउंट बनाएं ताकि आप अपनी API कुंजी प्राप्त कर सकें और CrewAI को एक लाइव वेब डेटा टूल से कनेक्ट कर सकें।

जब आप समझ जाएं कि आपके कार्यप्रवाह को कितने पृष्ठों और एजेंट कॉल की आवश्यकता है, तो स्क्रेपलेस मूल्य निर्धारण योजनाओं की समीक्षा करें।

कार्यान्वयन प्रश्नों और सामुदायिक समर्थन के लिए:

• स्क्रेपलेस डिस्कोर्ड में शामिल हों
• स्क्रेपलेस टेलीग्राम समुदाय में शामिल हों

सामान्य प्रश्न

प्रश्न: क्या CrewAI क्रू को चलाने के लिए एक क्लाउड LLM कुंजी की आवश्यकता है?

नहीं। model="ollama/qwen2.5:0.5b" और base_url="http://localhost:11434" सेट करना प्रत्येक एजेंट को स्थानीय ओलामा सर्वर की ओर इंगित करता है। क्रू को OpenAI, एंथ्रोपिक, या अन्य होस्टेड LLM कुंजी की आवश्यकता नहीं है।

इस कार्यप्रवाह को अभी भी एक स्क्रेपलेस API कुंजी की आवश्यकता है क्योंकि फ़ेचर दूरस्थ स्क्रेपलेस MCP सर्वर को कॉल करता है।

प्रश्न: CrewAI एक एजेंट से अगले एजेंट तक आउटपुट कैसे पास करता है?

प्रत्येक डाउनस्ट्रीम Task को एक context सूची मिलती है जिसमें एक पूर्व कार्य होता है।

उदाहरण के लिए:

extract_task = Task(
    ...,
    context=[fetch_task],
)

CrewAI एक्सट्रैक्टर के संदर्भ में फ़ेच कार्य का अंतिम उत्तर शामिल करता है। वही तंत्र निकासी परिणाम को वैलिडेटर में पास करता है।

प्रश्न: केवल फ़ेचर को ही MCP टूल क्यों मिलता है?
फेचर केवल एजेंट है जो लाइव पृष्ठ सामग्री को पुनः प्राप्त करने के लिए जिम्मेदार है। निष्कर्ष निकालने वाला और मान्यता देने वाला मौजूदा कार्य आउटपुट पर काम करना चाहिए।

उपकरणों की पहुँच को सीमित करने से अनावश्यक विकल्पों को कम किया जाता है और कार्यप्रवाह को ऑडिट करना आसान होता है।

प्र: max_iter=2 क्या नियंत्रित करता है?

max_iter यह सीमित करता है कि एक एजेंट एक कार्य के दौरान कितने तर्क और कार्रवाई के चक्र कर सकता है।

2 का मान फेचर को एक उपकरण कॉल और अंतिम प्रतिक्रिया के लिए जगह देता है जबकि एक खुला लूप रोकता है। यह कार्यान्वयन को सीमित करता है, लेकिन यह सुनिश्चित नहीं करता कि एजेंट का अंतिम उत्तर सही है।

प्र: क्या छोटे स्थानीय मॉडल ने सही उद्धरण निकाला?

नहीं। क्रू ने कार्य पूरा किया, लेकिन अंतिम मान्यता देने वाला आउटपुट इस प्रकार शुरू हुआ:

0  ["", "", ""]

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

प्र: यदि क्रू के पास पहले से एक QA एजेंट है, तो निर्णायक मान्यता का उपयोग क्यों करें?

एक QA एजेंट अभी भी एक LLM है। यह गायब फ़ील्ड को अनदेखा कर सकता है या उस डेटा के साथ संघर्ष कर सकता है जिसे इसे निरीक्षण करने के लिए कहा गया था।

निर्णायक पायथन जांच JSON सिंटैक्स, एरे की लंबाई, आवश्यक फ़ील्ड और स्रोत मिलान के आधार पर एक स्वतंत्र पास/फेल निर्णय प्रदान करते हैं।

प्र: स्थानीय ओलामा रन कितना धीमा था?

पूर्ण सत्यापन रन ने परीक्षण किए गए होस्ट पर 542 सेकंड लिए। यह माप केवल परीक्षण में प्रयुक्त विशेष हार्डवेयर, मॉडल, पृष्ठ, प्रॉम्प्ट और एजेंट कॉन्फ़िगरेशन पर लागू होता है।

जब कई एजेंट टर्न शामिल होते हैं, तो स्थानीय CPU अनुमानित समय में मिनट लग सकते हैं।

प्र: एक उत्पादन क्रू में क्या लॉग किया जाना चाहिए?

कम से कम निम्नलिखित को संरक्षित करें:

• MCP उपकरण प्रतिक्रिया
• हर मध्यवर्ती कार्य आउटपुट
• पार्स किया गया संरचित डेटा
• निर्णायक मान्यता त्रुटियाँ
• अंतिम क्रू परिणाम
• प्रत्येक चरण के लिए कार्यान्वयन समय

यह उस चरण का पता लगाने की अनुमति देता है जिसने स्रोत डेटा को बदला या छोड़ा।

प्र: मैं एक लाइव वेबसाइट को स्क्रैप करने से पहले क्या जांचूं?

वेबसाइट के नियमों और /robots.txt निर्देशों की समीक्षा करें, जो रोबोट्स निषेध प्रोटोकॉल के अनुसार हैं।

लक्ष्य सूची सीमित रखें, सार्वजनिक पृष्ठों का उपयोग करें, और एक स्वायत्त एजेंट को खुला कर्लिंग निर्देश देने से बचें।