Python में एक AI एजेंट कैसे बनाएं

TL;DR:

• AI एजेंट एक लूप है: मॉडल एक उपकरण चुनता है, आपका कोड उसे चलाता है, परिणाम मॉडल के पास वापस जाता है। बुद्धिमत्ता भाषा मॉडल है; पहुँच उन उपकरणों से आती है जो आप इसे देते हैं। शोध और निगरानी के लिए, दो महत्वपूर्ण उपकरण हैं वेब खोज और पृष्ठ फ़ेच।
• एजेंट को वास्तविक वेब उपकरण दें, बर्फ़ीली प्रशिक्षण सेट नहीं। एक web_search उपकरण, जो Deep SerpApi द्वारा समर्थित है, लाइव Google परिणाम लौटाता है, और एक fetch_page उपकरण, जो Universal Scraping API द्वारा समर्थित है, रेंडर किए गए HTML को लौटाता है — ताकि एजेंट वर्तमान डेटा पर तर्क कर सके, पिछले वर्ष के डेटा पर नहीं।
• दोनों उपकरण एक HTTP POST हैं। खोज करता है POST /api/v1/scraper/request के साथ scraper.google.search अभिनेता; फ़ेच करता है POST /api/v1/unlocker/request के साथ js_render चालू। कोई ब्राउज़र प्रबंधन करने की आवश्यकता नहीं, कोई प्रॉक्सी पूल घुमाने की आवश्यकता नहीं।
• मॉडल नियंत्रण प्रवाह का मालिक है। आप उपकरण के हस्ताक्षर को उजागर करते हैं, मॉडल तय करता है कि क्या कॉल करना है और कब, और आप निष्पादित करते हैं और परिणामों को वापस खिलाते हैं जब तक कि यह उत्तर नहीं देता — वह लूप पूरे एजेंट का है।
• उपकरण स्तर को निरूपित और सत्यापित रखें। खोज और फ़ेच कॉल्स संरचित डेटा लौटाते हैं जिसे आप मॉडल से स्वतंत्र रूप से परीक्षण कर सकते हैं, जहाँ से विश्वसनीयता आती है।
• शुरू करने के लिए स्वतंत्र। नए Scrapeless खातों में मुफ्त Deep SerpApi रनटाइम शामिल है — app.scrapeless.com पर साइन अप करें।

परिचय: एक एजेंट की गुणवत्ता उसके उपकरणों पर निर्भर करती है

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

कड़ी मेहनत का हिस्सा शायद ही कभी लूप होता है — यह उपकरण होते हैं। एक शोध एजेंट को खुले वेब पर खोज करनी होती है और वह पृष्ठ पढ़ने होते हैं जो वह खोजता है, और ये दोनों वास्तविक साइटों पर विफल हो जाते हैं: खोज इंजन दर-सीमा, और लक्षित पृष्ठ जैविक रक्षित सलाहों के पीछे होते हैं। यह सभी कार्य को हैंड-रोल करना पड़ता है।

यह गाइड एक शोध एजेंट बनाता है जो Python में दोनों उपकरणों को HTTP कॉल के रूप में प्रबंधित करता है: web_search Scrapeless Deep SerpApi पर चलता है और fetch_page Universal Scraping API पर चलता है। नीचे का उपकरण स्तर लाइव API के खिलाफ सत्यापित है; मॉडल तर्क लूप मानक उपकरण-कालिंग पैटर्न के साथ दिखाए गए हैं। केवल सार्वजनिक डेटा।

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

एजेंट के चार भाग हैं, और केवल मध्य दो वेब को छूते हैं:

1. उद्देश्य इन — उपयोगकर्ता से एक प्रश्न या शोध कार्य।
2. web_search(query) — Deep SerpApi के माध्यम से लाइव Google परिणाम (शीर्षक, लिंक, स्निपेट)।
3. fetch_page(url) — Universal Scraping API के माध्यम से किसी भी परिणाम के लिए रेंडर किया गया HTML जो मॉडल पढ़ना चाहता है।
4. मॉडल लूप — भाषा मॉडल तय करता है कि कौन सा उपकरण कॉल करना है, परिणाम पढ़ता है, और या तो एक और उपकरण कॉल करता है या अंतिम उत्तर लिखता है।

चरण 2 और 3 ऐसे निरूपित HTTP कॉल हैं जिनका आप स्वतंत्र रूप से सत्यापन कर सकते हैं। चरण 4 मॉडल है; चरण 1–3 वह हैं जो इसके उत्तरों को वर्तमान बनाते हैं।

आवश्यकताएँ

• Python 3.10 या नया
• pip install requests (अपने मॉडल प्रदाता के SDK के साथ)
• एक Scrapeless खाता और API कुंजी - app.scrapeless.com पर साइन अप करें
• तर्क लूप के लिए एक मॉडल प्रदाता API कुंजी (चरण 3)

export SCRAPELESS_API_KEY="your_api_token_here"

चरण 1 — वेब खोज उपकरण

खोज उपकरण एक प्रश्न को Deep SerpApi Google खोज अभिनेता को पोस्ट करता है और एक संक्षिप्त सूची लौटाता है जो जैविक परिणाम - शीर्षक, लिंक, और स्निपेट - है, जो बिल्कुल है वही जो एक मॉडल को अगला पढ़ने का निर्णय लेने के लिए चाहिए:

import os
import requests

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

def web_search(query: str, count: int = 5):
    r = requests.post(
        f"{API}/api/v1/scraper/request",
        headers=HEADERS,
        json={
            "actor": "scraper.google.search",
            "input": {"q": query, "hl": "en", "gl": "us"},
        },
        timeout=90,
    )
    r.raise_for_status()
    results = r.json().get("organic_results", [])[:count]
    return [
        {"title": x.get("title"), "link": x.get("link"), "snippet": x.get("snippet")}
        for x in results
    ]


# इसे अपने आप चलाएँ ताकि आकार की पुष्टि हो सके:
hits = web_search("2026 के लिए सर्वश्रेष्ठ वेब स्क्रैपिंग उपकरण", 3)
print(len(hits), "परिणाम")
for h in hits:
    print("-", h["title"], "|", h["link"])

अभिनेता organic_results लौटाता है जिसमें मानक खोज क्षेत्र होते हैं; यह कार्यशील मॉडल के संदर्भ को फैलाने से रोकने के लिए इसे शीर्ष count में ट्रिम करता है।

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

चरण 2 — पृष्ठ फ़ेच उपकरण

एक बार जब मॉडल एक परिणाम पढ़ने के लिए चुनता है, तो उसे पृष्ठ सामग्री की आवश्यकता होती है। फ़ेच टूल URL को यूनिवर्सल स्क्रैपिंग एपीआई पर js_render सक्षम करके पोस्ट करता है, ताकि क्लाइंट-रेन्डर्ड पृष्ठ पूर्ण HTML के रूप में लौटें, न कि एक खाली खोल के रूप में:

import os
import requests

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

def fetch_page(url: str):
    r = requests.post(
        f"{API}/api/v1/unlocker/request",
        headers=HEADERS,
        json={
            "actor": "unlocker.webunlocker",
            "input": {"url": url, "method": "GET", "js_render": True},
        },
        timeout=120,
    )
    r.raise_for_status()
    return r.json().get("data", "")


# एक रेंडर की गई पृष्ठ को फ़ेच करें और पुष्टि करें कि हमें HTML वापस मिलता है:
html = fetch_page("https://www.scrapeless.com/en")
print("फ़ेच किया गया", len(html), "बाइट्स")

मॉडल को HTML देने से पहले, इसे टेक्स्ट में बदल दें (या selectolax या BeautifulSoup का उपयोग कर) ताकि आप सामग्री पर संदर्भ खर्च करें, न कि मार्कअप पर। टूल को स्वयं कच्चा HTML वापस करते रहिए — एजेंट तय करे कि उसे कितना पढ़ना है।

चरण 3 — मॉडल लूप

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

नोट: यह चरण आपके मॉडल प्रदाता को कॉल करता है और उस प्रदाता की एपीआई कुंजी की आवश्यकता होती है। ऊपर दिए गए टूल फ़ंक्शन स्वायत्त रूप से पूरी तरह से चलने योग्य हैं; नीचे दिया गया लूप मानक टूल- कॉलिंग पैटर्न है जो उन्हें जोड़ा गया है।

TOOLS = [
    {
        "name": "web_search",
        "description": "एक प्रश्न के लिए Google में खोजें; शीर्षक, लिंक, स्निपेट लौटाता है।",
        "input_schema": {
            "type": "object",
            "properties": {"query": {"type": "string"}},
            "required": ["query"],
        },
    },
    {
        "name": "fetch_page",
        "description": "एक URL का रेंडर किए गए HTML को फ़ेच करें।",
        "input_schema": {
            "type": "object",
            "properties": {"url": {"type": "string"}},
            "required": ["url"],
        },
    },
]

DISPATCH = {"web_search": web_search, "fetch_page": fetch_page}

def run_agent(client, goal: str):
    messages = [{"role": "user", "content": goal}]
    while True:
        reply = client.run(messages=messages, tools=TOOLS)  # प्रदाता टूल-कॉलिंग कॉल
        if reply.tool_call:
            name, args = reply.tool_call.name, reply.tool_call.args
            result = DISPATCH[name](**args)
            messages.append({"role": "tool", "name": name, "content": result})
            continue
        return reply.text

आकार प्रदाता-निष्पक्ष है: प्रत्येक प्रमुख टूल- कॉलिंग एपीआई आपको "मॉडल टूल X को आर्ग्स Y के साथ कॉल करना चाहता है" देता है, आप DISPATCH[X](**Y) चलाते हैं, परिणाम को संलग्न करते हैं, और लूप करते हैं। एजेंट की क्षमता इन दो उपकरणों पर आती है जो वास्तविक, वर्तमान डेटा लौटाते हैं — जो इस गाइड ने सत्यापित किया है।

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

प्रत्येक web_search परिणाम एक फ्लैट रिकॉर्ड है जिसे मॉडल सीधे तर्क कर सकता है:

[
  {
    "title": "2026 में सबसे अच्छे वेब स्क्रैपिंग उपकरण",
    "link": "https://dev.to/nitinfab/best-web-scraping-tools-in-2026-i-tested-30-tools-and-these-are-the-only-ones-worth-using-11l3",
    "snippet": "एक हाथों-हाथ तुलना स्क्रैपिंग उपकरणों की जो रेंडरिंग, प्रॉक्सी और कीमत में हैं ..."
  }
]
// स्कीमा बिल्कुल वही दर्शाता है जो web_search लौटाता है। फ़ील्ड मान उदाहरण के लिए हैं।

कुछ ईमानदार अवलोकन:

• खोज परिणामों को ट्रिम करें इससे पहले कि वे मॉडल तक पहुँचें। ऊपर के तीन से पांच आमतौर पर पर्याप्त होते हैं; संपूर्ण SERP संदर्भ और धन बर्बाद करता है।
• एजेंट में HTML को टेक्स्ट में कनवर्ट करें, टूल में नहीं। fetch_page को कच्चा HTML लौटाना जारी रखें ताकि यह निश्चित बना रहे; जहां आप टोकन बजट को नियंत्रित करते हैं, वहाँ सफाई करें।
• लूप को कैप करें। एजेंट को अधिकतम टूल-कॉल संख्या दें ताकि एक कंफ्यूज़्ड रन घूम न सके - एक कठिन कैप, न कि फिर से रन。
• उपकरण स्वतंत्र रूप से परीक्षण योग्य हैं। क्योंकि खोज और फ़ेच सामान्य HTTP हैं, आप उन्हें बिना मॉडल के लूप में परीक्षण कर सकते हैं, जहाँ विश्वसनीयता रहती है।

निष्कर्ष: टूल एजेंट बनाते हैं

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

क्या आप अपने एआई-संचालित डेटा पाइपलाइन के लिए तैयार हैं?

हमारे समुदाय में शामिल हों और एजेंटों और शोध पाइपलाइनों का निर्माण करने वाले डेवलपर्स के साथ जुड़ें: Discord · Telegram।

app.scrapeless.com पर निशुल्क दीप सर्पएपी रनटाइम के लिए साइन अप करें और खोज और फ़ेच उपकरणों को उस एजेंट ढांचे में वायर करें जिसका आप पहले से उपयोग कर रहे हैं। स्केल के लिए मूल्य निर्धारण देखें।

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

प्रश्न: क्या मुझे इसे बनाने के लिए एक विशेष मॉडल प्रदाता की आवश्यकता है?
नहीं। लूप प्रदाता-agnostic है - कोई भी टूल-को कॉल करने वाली एपीआई काम करती है। client.run(...) कॉल को अपने प्रदाता के लिए स्वेप करें; web_search और fetch_page उपकरण समान रहते हैं।

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

प्रश्न: क्या एजेंट की वेब एक्सेस वैध है?
एजेंट सार्वजनिक रूप से उपलब्ध डेटा एकत्र करता है। आप इसे कैसे संग्रहीत और उपयोग करते हैं यह प्रत्येक साइट की सेवा की शर्तों और स्थानीय कानून द्वारा शासित होता है - केवल सार्वजनिक डेटा तक पहुँचें, ToS का सम्मान करें, और अपने उपयोग के मामले के लिए सलाहकार से परामर्श करें।

प्रश्न: मैं एजेंट को अनंत लूप से कैसे रोकूं?
प्रति रन उपकरण कॉल की संख्या को सीमित करें और जब सीमा हिट हो जाए तो रुक जाएं। यह नियंत्रण प्रवाह पर एक कठिन छत है, न कि त्रुटि हैंडलिंग पर।

प्रश्न: फ़ेच किए गए पृष्ठ कितने बड़े हो सकते हैं?
बड़े - एक एकल सामग्री पृष्ठ सैकड़ों किलोबाइट्स HTML लौटा सकता है। इसे टेक्स्ट में परिवर्तित करें और इसे मॉडल को पास करने से पहले काटें ताकि आप संदर्भ बजट को नियंत्रित कर सकें।

प्रश्न: क्या एजेंट दो से अधिक उपकरणों का उपयोग कर सकता है?
हाँ। कोई भी उपकरण जो संरचित डेटा लौटाता है - एक गूगल मैप्स अभिनेता, एक समाचार खोज, एक डेटाबेस क्वेरी - को TOOLS सूची और DISPATCH मानचित्र में जोड़ें, और मॉडल इसे उसी तरह कॉल कर सकता है।