OpenAI एजेंट्स SDK + स्क्रेपलेस: आपके एजेंट्स के लिए वेब उपकरण MCP के माध्यम से

संक्षेप में:

• OpenAI एजेंट्स SDK एक ऑब्जेक्ट MCPServerStreamableHttp के माध्यम से Scrapeless MCP सर्वर से जुड़ता है, जिसमें एन्डपॉइंट और x-api-token हेडर होता है।
• await server.list_tools() सभी 21 टूल लौटाता है - scrape_markdown, scrape_html, google_search, google_trends, scrape_screenshot, और एक 16-टूल browser_* सेट - जिसमें केवल Scrapeless कुंजी सेट होती है।
• उन ढांचों के विपरीत जो MCP टूल्स को स्वतंत्र ऑब्जेक्ट में परिवर्तित करते हैं, SDK सर्वर को एक प्रथम श्रेणी के कनेक्शन के रूप में रखता है: आप पूरी server को एजेंट को सौंपते हैं, और यह आपके लिए list_tools और call_tool को कॉल करता है।
• आप किसी भी टूल को सीधे await server.call_tool("scrape_markdown", {"url": ...}) के साथ कॉल कर सकते हैं इससे पहले कि एजेंट शामिल हो - टूल्स को लोड या कॉल करने के लिए कोई मॉडल कुंजी की आवश्यकता नहीं है।
• केवल Runner.run को एक मॉडल-प्रदात्री कुंजी की आवश्यकता होती है, क्योंकि यही वह कदम है जहां मॉडल यह तय करता है कि कौन से टूल्स को कॉल करना है।
• Scrapeless मुफ्त योजना से शुरू करें और अपने OpenAI एजेंट SDK एजेंटों को वास्तविक वेब टूल्स दें।

OpenAI एजेंट्स SDK OpenAI का हल्का फ्रेमवर्क है जिसका उपयोग Python में एजेंटिक ऐप्स बनाने के लिए किया जाता है, और इसमें एक एजेंट उतना ही उपयोगी होता है जितने टूल्स आप इसे देते हैं। आधार स्थापना में कुछ भी लाइव वेब तक नहीं पहुंचता। मॉडल संदर्भ प्रोटोकॉल इस मुद्दे को ठीक करता है: SDK को MCP सर्वर पर निर्देशित करें और उस सर्वर द्वारा प्रदर्शित प्रत्येक टूल आपके एजेंट द्वारा एक हस्तलिखित फ़ंक्शन टूल के समान इंटरफेस के माध्यम से कॉल किया जा सकता है।

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

Scrapeless MCP सर्वर एजेंट को क्या देता है

Scrapeless MCP सर्वर वेब-स्क्रैपिंग और ब्राउज़र टूल्स का खुलासा करता है जिन्हें एक एजेंट सीधे कॉल कर सकता है, इसलिए स्क्रैपिंग लेयर ऐसा कुछ नहीं है जिसे आप बनाते या होस्ट करते हैं। एक कनेक्शन 21 टूल्स की सेवा करता है: पृष्ठ सामग्री के लिए scrape_markdown और scrape_html, खोज डेटा के लिए google_search और google_trends, कैप्चर के लिए scrape_screenshot, और 16-टूल browser_* सेट जो क्लिक, टाइपिंग, स्क्रॉलिंग और प्रतीक्षा के माध्यम से एक क्लाउड ब्राउज़र को संचालित करता है।

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

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

• Python 3.10 या उससे बाद का संस्करण।
• डैशबोर्ड से एक Scrapeless API कुंजी, जिसे SCRAPELESS_API_KEY के रूप में निर्यात किया गया है।
• केवल एजेंट रन के लिए एक मॉडल-प्रदात्री कुंजी जैसे OPENAI_API_KEY। टूल्स को लोड और कॉल करने के लिए इसकी आवश्यकता नहीं है।

स्थापना

SDK स्थापित करें। MCP क्लाइंट इसके अंदर शिप होता है, इसलिए जोड़ने के लिए कोई अलग तत्व नहीं है।

pip install "openai-agents==0.18.3"

अपने Scrapeless कुंजी को शेल में सेट करें, और प्लेसहोल्डर को अपने स्रोत से बाहर रखें।

export SCRAPELESS_API_KEY="sk_your_key_here"

कनेक्ट करें और टूल्स लोड करें

MCPServerStreamableHttp एक params डिक्शनरी लेता है जिसमें एन्डपॉइंट और हेडर्स होते हैं, और यह एक असिंक्रोनस कॉन्टेक्स्ट प्रबंधक है, इसलिए कनेक्शन एक with ब्लॉक के चारों ओर खुलता और बंद होता है। list_tools हैंडशेक चलाता है और सर्वर के टूल्स लौटाता है।

import asyncio
import os

from agents.mcp import MCPServerStreamableHttp


async def main() -> None:
    params = {
        "url": "https://api.scrapeless.com/mcp",
        "headers": {"x-api-token": os.environ["SCRAPELESS_API_KEY"]},
    }
    async with MCPServerStreamableHttp(
        params=params, name="scrapeless", client_session_timeout_seconds=60
    ) as server:
        tools = await server.list_tools()
        names = sorted(tool.name for tool in tools)
        print("tool count:", len(names))
        print("tools:", ", ".join(names))


asyncio.run(main())

लाइव सर्वर 21 टूल्स लौटाता है, जिसमें केवल Scrapeless कुंजी सेट होती है।

tool count: 21
tools: browser_click, browser_close, browser_create, browser_get_html, browser_get_text, browser_go_back, browser_go_forward, browser_goto, browser_press_key, browser_screenshot, browser_scroll, browser_scroll_to, browser_snapshot, browser_type, browser_wait, browser_wait_for, google_search, google_trends, scrape_html, scrape_markdown, scrape_screenshot

परिवहन और संदेश परत मॉडल संदर्भ प्रोटोकॉल विशिष्टता का पालन करती है, जो JSON-RPC 2.0 विशिष्टता पर आधारित है। SDK में एक स्थानीय उपप्रक्रिया सर्वर के लिए MCPServerStdio भी शामिल है; Scrapeless सर्वर एक होस्टेड HTTP अंत बिंदु है, इसलिए धारित-HTTP वर्ग यहाँ सही है।

एक उपकरण को सीधे कॉल करें

एक एजेंट मौजूद होने से पहले, आप सर्वर पर किसी भी टूल को स्वयं कॉल कर सकते हैं। call_tool टूल नाम और एक तर्क डिक्ट लेता है और एक CallToolResult लौटाता है जिसका content ब्लॉकों की एक सूची होती है; पाठ टेक्स्ट ब्लॉकों पर होता है।

import asyncio
import os

from agents.mcp import MCPServerStreamableHttp


async def main() -> None:
    params = {
        "url": "https://api.scrapeless.com/mcp",
        "headers": {"x-api-token": os.environ["SCRAPELESS_API_KEY"]},
    }
    async with MCPServerStreamableHttp(
        params=params, name="scrapeless", client_session_timeout_seconds=60
    ) as server:
        result = await server.call_tool("scrape_markdown", {"url": "https://quotes.toscrape.com/"})
        text = "".join(block.text for block in result.content if block.type == "text")
        print("markdown chars:", len(text))
        print("contains a quote:", "Einstein" in text)


asyncio.run(main())

कॉल पृष्ठ को Markdown के रूप में लौटाता है, और सामग्री जांच यह पुष्टि करती है कि वास्तविक पाठ लौटाया गया है।

markdown chars: 4308
contains a quote: True

यह वही आकार है जो एजेंट उसी टूल से वापस प्राप्त करता है: पृष्ठ सामग्री जिस पर वह तर्क कर सकता है। OpenAI एजेंट SDK MCP दस्तावेज़ list_tools, call_tool, और cache_tools_list विकल्प को कवर करता है जो स्थिर टूल सेट होने पर पुनरावृत्त हस्तक्षेपों को छोड़ता है।

उपकरणों को एक एजेंट को सौंपें

यहाँ SDK टूल-एडेप्टर ढांचों से भिन्न है। आप टूल का रूपांतरण नहीं करते हैं और एक सूची नहीं देते; आप पूरी server को एजेंट के mcp_servers तर्क में पास करते हैं, और एजेंट इसके दौरान list_tools और call_tool का उपयोग करता है। यह वही कदम है जिसे एक मॉडल-प्रदाता कुंजी की आवश्यकता होती है।

नोट: Runner.run को एक मॉडल-प्रदाता कुंजी की आवश्यकता होती है जैसे कि OPENAI_API_KEY, जो यहाँ सेट नहीं है। 21 उपकरणों को लोड करना और ऊपर का सीधा scrape_markdown कॉल इसके बिना चलता है। यह ब्लॉक अपने सटीक आकार के साथ दिखाया गया है; केवल मॉडल राउंड-ट्रिप एक पूर्वापेक्षा अंतर है।

import asyncio
import os

from agents import Agent, Runner
from agents.mcp import MCPServerStreamableHttp


async def main() -> None:
    params = {
        "url": "https://api.scrapeless.com/mcp",
        "headers": {"x-api-token": os.environ["SCRAPELESS_API_KEY"]},
    }
    async with MCPServerStreamableHttp(
        params=params, name="scrapeless", client_session_timeout_seconds=60
    ) as server:
        agent = Agent(
            name="web_agent",
            instructions="Scrapeless उपकरणों का उपयोग करके पृष्ठों को लाएं और पढ़ें।",
            mcp_servers=[server],
        )
        result = await Runner.run(
            agent,
            "scrape_markdown का उपयोग करके https://quotes.toscrape.com/ लाएं और पहले तीन उद्धरणों को लेखकों के साथ सूचीबद्ध करें।",
        )
        print(result.final_output)


asyncio.run(main())

रन टाइम पर मॉडल कार्य को पढ़ता है, URL के साथ scrape_markdown को कॉल करता है, पहले से लौटे Markdown को प्राप्त करता है, और उत्तर लिखता है। उपकरण दोनों मामलों में समान हैं — केवल नया घटक वह मॉडल है जो उन्हें कब कॉल करना है यह तय करता है।

निष्कर्ष

OpenAI एजेंट SDK और Scrapeless MCP सर्वर एक निर्जीव एजेंट से एक ऐसा एजेंट बनाने का एक छोटा रास्ता है जो लाइव वेब को पढ़ता है। एक MCPServerStreamableHttp ऑब्जेक्ट कनेक्शन खोलता है, list_tools सभी 21 उपकरण लौटाता है, call_tool साबित करता है कि एक काम करता है, और एकल mcp_servers=[server] तर्क सेट को एजेंट को सौंपता है। केवल निर्माण चरण को एक मॉडल कुंजी की आवश्यकता होती है, इसलिए आप पहले पूरे उपकरण की सतह को तार और परीक्षण कर सकते हैं। ऊपर के स्क्रिप्ट से शुरू करें, उपकरणों को कार्य की आवश्यकता के अनुसार सीमित करें, और मॉडल को चलने दें।

एक मुफ्त Scrapeless खाता बनाएँ एक API कुंजी प्राप्त करने के लिए, और जब आप एक आवर्ती एजेंट की योजना बनाते हैं तो Scrapeless कीमतें को देखें।

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

प्रश्न: क्या OpenAI एजेंट SDK को MCP उपकरणों को लोड करने के लिए एक मॉडल कुंजी की आवश्यकता होती है?

नहीं। MCPServerStreamableHttp हैंडशेक को चलाता है और list_tools केवल Scrapeless API कुंजी सेट होने के साथ उपकरण लौटाता है, और call_tool किसी भी उपकरण को सीधे कॉल करता है। एक मॉडल-प्रदाता कुंजी केवल तब आवश्यक होती है जब आप सर्वर को एक Agent में पास करते हैं और Runner.run को कॉल करते हैं, क्योंकि यही वह समय है जब मॉडल तय करता है कि कौन से उपकरणों को कॉल करना है।
Q: मुझे एक MCP टूल को बिना एजेंट बनाए कैसे कॉल करना है?

सर्वर को एक असिंक्रोनस संदर्भ प्रबंधक के रूप में खोलें और await server.call_tool(name, arguments) कॉल करें। यह एक CallToolResult लौटाता है जिसका content ब्लॉकों की एक सूची है; टेक्स्ट ब्लॉकों से टेक्स्ट पढ़ें। यह कनेक्शन की पुष्टि करने और किसी भी मॉडल के शामिल होने से पहले एक टूल के आउटपुट की जांच करने का सबसे तेज़ तरीका है।

Q: सर्वर को टूल्स की सूची के बजाय पास करने का कारण क्या है?

SDK MCP सर्वर को एक जीवित कनेक्शन के रूप में रखता है और रन के दौरान इसे पूछता है, इसलिए आप इसे mcp_servers=[server] के साथ संलग्न करते हैं न कि प्रत्येक टूल को बदलते हैं। यदि टूल सेट स्थिर है, तो सर्वर पर cache_tools_list=True सेट करें ताकि यह हर टर्न पर हैंडशेक को पुनः न चलाए।

Q: क्या मैं इसके बजाय एक स्थानीय MCP सर्वर से कनेक्ट कर सकता हूँ?

हाँ। MCPServerStreamableHttp को MCPServerStdio से स्वैप करें और इसे आपके स्थानीय सर्वर को लॉन्च करने वाली कमांड दें, फिर इसे एजेंट को उसी तरह पास करें। Scrapeless MCP सर्वर एक होस्टेड HTTP एंडपॉइंट है, इसलिए यह गाइड स्ट्रीम योग्य-HTTP वर्ग का उपयोग करता है।

Q: क्या टूल्स के माध्यम से स्क्रैपिंग लक्ष्यों के नियमों से बंधी होती है?

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