कैसे Scrapeless को एक कस्टम GPT क्रिया के साथ ChatGPT से जोड़ा जाए

TL;DR:

• ChatGPT एक API-key MCP सर्वर को कनेक्टर के रूप में नहीं ले सकता। डेवलपर-मोड MCP OAuth 2.1 या कोई प्रमाणीकरण स्वीकार करता है, और OpenAI का अपना दस्तावेज़ कहता है कि ChatGPT "कस्टम API कुंजी प्रस्तुत नहीं कर सकता"।
• जो मार्ग काम करता है वह एक कस्टम GPT Action है: एक OpenAPI स्कीमा प्लस API-key प्रमाणीकरण एक कस्टम हेडर पर।
• हेडर x-api-token है, Authorization: Bearer नहीं। प्रमाणीकरण प्रकार को API Key पर सेट करें, फिर Custom, फिर उस हेडर नाम पर।
• Markdown के लिए पूछें, HTML के लिए नहीं। वही पृष्ठ Markdown के रूप में 8,676 वर्ण बनाम HTML के रूप में 50,403 है — यह उस संदर्भ में 83% कटौती है जिसमें मॉडल मार्कअप पर समय बिताता है।
• response_type केवल js_render: true के साथ करता है। js_render को छोड़ दें और वही अनुरोध 50,368 वर्ण के HTML के साथ HTTP 200 लौटाता है। outputFormat को स्वीकार किया जाता है और चुपचाप अनदेखा किया जाता है, जो पूर्ण 50,403 वर्ण के HTML को लौटाता है।
• नीचे का स्कीमा openapi-spec-validator को OpenAPI 3.1.0 के खिलाफ पास करता है, और जिस अनुरोध का वर्णन किया गया था वह लाइव संपादित किया गया था: {code: 200, data: string}।
• शुरू करने से पहले Scrapeless मुफ्त योजना पर एक कुंजी प्राप्त करें।

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

निर्धारित करने वाली पहली बात यह है कि ChatGPT वास्तव में कौन सा तंत्र स्वीकार करेगा, क्योंकि स्पष्ट उत्तर गलत है।

क्यों यह एक Action है और न कि एक MCP कनेक्टर

अन्य सभी प्रमुख क्लाइंट Scrapeless MCP सर्वर को एक दूरस्थ HTTP कनेक्टर के रूप में लेते हैं जिसमें हेडर पर कुंजी होती है। ChatGPT ऐसा नहीं करता, और इसके चारों ओर बनाने से पहले यह देखने लायक है कि क्यों।

एंडपॉइंट को एक स्थिर हेडर की आवश्यकता होती है। बिना एक के बुलाए:

POST https://api.scrapeless.com/mcp   (no auth)
-> HTTP 401
   body: Unauthorized: Missing x-api-token header
   www-authenticate: None

वह गायब www-authenticate हेडर महत्वपूर्ण है। HTTP प्रमाणीकरण ढांचे के तहत 401 वह जगह है जहाँ एक सर्वर प्रमाणीकरण करने का तरीका बताता है, और एक क्लाइंट जो OAuth चुनौती की तलाश कर रहा है वह अनुगामी सामग्री नहीं पाता। न कोई OAuth मेटाडेटा खोजने के लिए है:

/.well-known/oauth-protected-resource       404
/.well-known/oauth-authorization-server     404
/.well-known/oauth-protected-resource/mcp   404

मॉडल संदर्भ प्रोटोकॉल विनिर्देशन दोनों व्यवस्था की अनुमति देता है - हेडर पर एक नग्न टोकन एक पूरी तरह से सामान्य MCP तैनाती है। बाधा ChatGPT की तरफ है: इसके डेवलपर-मोड कनेक्टर OAuth 2.1 या कोई प्रमाणीकरण का समर्थन करते हैं, और OpenAI का दस्तावेज़ स्पष्ट रूप से बताता है कि ChatGPT कस्टम API कुंजी प्रस्तुत नहीं कर सकता।

इसलिए यहाँ कोई URL चिपकाने के लिए नहीं है। एक कुंजी वाले HTTP API के लिए समर्थित पथ एक GPT Action है, जो एक हेडर नाम के साथ API-key प्रमाणीकरण का समर्थन करता है जिसे आप चुनते हैं।

आवश्यकताएँ

• एक ChatGPT योजना जिसमें GPT बनाने की अनुमति हो।
• एक Scrapeless API कुंजी।
• कोई होस्टिंग, कोई प्रॉक्सी, कोई स्थानीय प्रक्रिया नहीं। Action api.scrapeless.com को सीधे कॉल करता है।

चरण 1: OpenAPI स्कीमा

एक Action एक OpenAPI दस्तावेज़ है जो एक या अधिक संचालन का वर्णन करता है। यह एकल संचालन का वर्णन करता है: एक र rendered पृष्ठ लाना और इसे Markdown के रूप में वापस लाना।

openapi: 3.1.0
info:
  title: Scrapeless Universal Scraping API
  description: Fetch a fully rendered web page and return it as Markdown or HTML.
  version: "1.0.0"
servers:
  - url: https://api.scrapeless.com
paths:
  /api/v2/unlocker/request:
    post:
      operationId: scrapeWebPage
      summary: Fetch a web page with JavaScript rendering and return it as Markdown
      requestBody:
        required: true
        content:
          application/json:
            schema:
              type: object
              required: [actor, input]
              properties:
                actor:
                  type: string
                  enum: [unlocker.webunlocker]
                  description: The Scrapeless actor to run.
                input:
                  type: object
                  required: [url, js_render, response_type]
                  properties:
                    url:
                      type: string
                      format: uri
                      description: The page to fetch.
                    js_render:
                      type: boolean
                      enum: [true]
                      default: true
                      description: Must be true. response_type only takes effect when JavaScript rendering is on.
                    response_type:
                      type: string
                      enum: [markdown, html]
                      default: markdown
                      description: Return the page as Markdown or raw HTML.
      responses:
        "200":
          description: The rendered page.
          content:
            application/json:
              schema:
                type: object
                properties:
                  code:
                    type: integer
                  data:
                    type: string
                    description: The rendered page, as Markdown or HTML.
        "401":
          description: Missing or invalid API token.
components:
  securitySchemes:
    scrapelessApiKey:
      type: apiKey
      in: header
      name: x-api-token
security:
  - scrapelessApiKey: []

वहाँ तीन जानबूझकर विकल्प हैं।

actor एक enum है जिसमें एक मान होता है न कि एक मुक्त स्ट्रिंग। एक मॉडल को एक मुक्त-टेक्स्ट क्षेत्र दिया जाए तो वह अंततः एक अभिनेता का नाम आविष्कार करता है; एक enum केवल वैध मान को एकमात्र विकल्प बनाता है।

operationId scrapeWebPage है, और यही वह नाम है जिसे आप GPT के निर्देशों में संदर्भित करते हैं। एक अस्पष्ट id अस्पष्ट उपकरण चयन उत्पन्न करता है।

response_type डिफ़ॉल्ट के रूप में markdown पर है, कारण के लिए जो चरण 3 में है, और यह और js_render आवश्यक के रूप में सूचीबद्ध हैं। एक स्कीमा डिफ़ॉल्ट दस्तावेज़ है: यह मॉडल को क्षेत्र भेजने के लिए नहीं बनाता, और API का अपना डिफ़ॉल्ट js_render के लिए बंद है।

चिपकाने से पहले मान्यता प्राप्त करना तीस सेकंड के लायक है — OpenAPI 3.1.0 विनिर्देशन संरचना के बारे में सख्त है, और निर्माता के त्रुटि संदेश संक्षिप्त हैं:

pip install openapi-spec-validator

python3 -c "
from openapi_spec_validator import validate
from openapi_spec_validator.readers import read_from_filename
spec, _ = read_from_filename('scrapeless-action.yaml')
validate(spec)
print('valid')"

valid

चरण 2: प्रमाणीकरण

GPT निर्माता में, Action के प्रमाणीकरण पैनल को खोलें और सेट करें:

API Key के अंतर्गत डिफ़ॉल्ट बीयरर है, जो Authorization: Bearer <key> भेजता है। Scrapeless x-api-token को पढ़ता है और कुछ और नहीं, इसलिए डिफ़ॉल्ट छोड़ने से 401 उत्पन्न होता है जिसे निर्माता केवल तब सूचित करता है जब Action को पहली बार कॉल किया जाता है — जब स्कीमा पहले से ही मान्य किया गया हो।

नोट: बिल्डर एक वेब UI है, इसलिए इस चरण को इस लेख के लिए प्रमाणीकरण के भाग के रूप में निष्पादित नहीं किया गया। API के बारे में प्रत्येक दावा — स्कीमा, हेडर नाम, प्रतिक्रिया आकार और नीचे दिए गए आकार — लाइव कॉल से api.scrapeless.com के खिलाफ आता है।

चरण 3: मार्कडाउन के लिए पूछें

यह एक सेटिंग निर्धारित करती है कि कनेक्टर पढ़ने से पहले मॉडल के संदर्भ का कितना खर्च करता है, और अंतर मापने योग्य है।

उसी श्रेणी का पृष्ठ, दो बार लिया गया:

response_type=markdown      8,676 chars
default (html)             50,403 chars

मार्कडाउन 83% छोटा है। GPT क्रिया की प्रतिक्रिया मॉडल के संदर्भ में जाती है, इसलिए HTML लौटाते समय अधिकांश बजट टैग, इनलाइन स्क्रिप्ट और गुणों पर खर्च होता है जिन्हें मॉडल नजरअंदाज करेगा।

इसके बगल में एक जाल है। outputFormat ऐसा लगता है कि यह काम करना चाहिए और बिना शिकायत के स्वीकार किया जाता है:

input.response_type = "markdown"   ->  8,676 chars  (markdown)
input.outputFormat  = "markdown"   -> 50,403 chars  (HTML)

दूसरी कॉल सफल रही, HTTP 200 लौटाया, और चुपचाप HTML वापस दिया क्योंकि outputFormat एक पैरामीटर नहीं है जिसे अभिनेता पढ़ता है। एक अनजान कुंजी जो नजरअंदाज की जाती है, उसे खारिज करने के बजाय बग का कठिन प्रकार है — कुछ भी विफल नहीं होता, आउटपुट बस गलत आकार का होता है और आपकी बजट योजना से लगभग छह गुना बड़ा होता है।

दूसरा जाल अधिक चुप है। response_type केवल उस समय प्रभावी होता है जब जावास्क्रिप्ट रेंडरिंग चालू होती है, और API का डिफ़ॉल्ट बंद होता है। response_type: "markdown" को js_render: true के बिना भेजें और कॉल HTTP 200 लौटाता है जिसमें 50,368 वर्ण का HTML होता है, बिना किसी त्रुटि और बिना चेतावनी के। ऊपर दिया गया स्कीमा js_render को true से जोड़ता है और इसे ठीक इसी कारण के लिए आवश्यक के रूप में सूचीबद्ध करता है, और नीचे दिए गए निर्देश दोनों क्षेत्रों का नाम देते हैं।

क्या आप इसे अभी बना रहे हैं? Scrapeless मुफ्त योजना पर्याप्त अनुरोधों को कवर करती है ताकि क्रिया को अंत से अंत तक टेस्ट किया जा सके।

चरण 4: उसे कॉल करने वाले निर्देश

स्कीमा मॉडल को एक क्षमत देता है; निर्देश यह तय करते हैं कि कब इसका उपयोग करना है। संचालन का नाम स्पष्ट रूप से दें:

When the user gives you a URL, or asks about the current contents of a
specific page, call scrapeWebPage with that URL, js_render true and
response_type "markdown". Do not answer from memory when a URL is present.

Return what the page says, and quote the exact figures it contains rather
than paraphrasing them. If scrapeWebPage reports a 401, tell the user the
API key is missing or misconfigured and stop.

पहला पैराग्राफ उपकरण को एक ट्रिगर से बांधता है। इसके बिना, एक मॉडल जिसकी अपनी ब्राउज़िंग क्षमता है, कभी-कभी इसके बजाय इसका उपयोग करेगा और ऐसे परिणाम पैदा करेगा जिनका आपके स्कीमा में कोई संबंध नहीं है।

क्या वापस आता है

प्रतिक्रिया लिफाफा दो क्षेत्रों का होता है, और ऊपर दिया गया स्कीमा दोनों को घोषित करता है:

{
  "code": 200,
  "data": "-   [Home](https://books.toscrape.com/index.html)\n-   [Books](...)\n..."
}

जिवंत API के खिलाफ ठीक उसी शरीर की पुष्टि की जाती है जिसे स्कीमा वर्णित करता है:

HTTP 200
response keys      : ['code', 'data']
code               : 200 (int)
data               : str, 50403 chars
schema match       : code=integer:True  data=string:True

code Scrapeless की अपनी स्थिति है, जो HTTP स्थिति से अलग है — दोनों यहाँ 200 थे। data एकल स्ट्रिंग है, यही कारण है कि मॉडल एक दस्तावेज़ प्राप्त करता है न कि एक संरचना; यदि आप क्षेत्रों की तलाश कर रहे हैं, तो उन्हें निर्देशों में मांगें या उन्हें डाउनस्ट्रीम अपने आप पार्स करें।

निष्कर्ष

कनेक्टर एक संचालन और एक हेडर है। ChatGPT एक API-key MCP सर्वर नहीं लेगा — यह एक प्लेटफ़ॉर्म सीमा है, प्रमाणित 401 के साथ बिना OAuth चुनौती, तीन 404s जहां मेटाडेटा होना चाहिए था, और OpenAI के अपने बयान द्वारा — इसलिए तंत्र एक क्रिया है, और तंत्र कठिन हिस्सा नहीं है।

दो विकल्प जो यह तय करते हैं कि यह अच्छी तरह से काम करता है, दोनों छोटे हैं। कस्टम हेडर को x-api-token पर सेट करें, क्योंकि Bearer डिफ़ॉल्ट कॉल के समय विफल होता है न कि सेटअप पर। और response_type को markdown के साथ-साथ js_render: true पर सेट करें, क्योंकि 8,676 वर्ण के मार्कडाउन में सोचने के लिए जगह छोड़ता है जहाँ 50,403 वर्ण का HTML नहीं छोड़ता है — और क्योंकि वैध दिखने वाला outputFormat स्वीकार किया गया, नजरअंदाज किया गया, और बड़ा वापस दिया गया।

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

क्या आप ChatGPT को एक फ़ेच देने के लिए तैयार हैं जिसे आप नियंत्रित करते हैं? Scrapeless मुफ्त योजना के साथ शुरू करें और स्कीमा पेस्ट करें।

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

प्रश्न: क्या ChatGPT एक MCP सर्वर से कनेक्ट कर सकता है?
हाँ, लेकिन केवल एक OAuth 2.1 का उपयोग करके या बिना किसी प्रमाणीकरण के। डेवलपर-मोड कनेक्टर स्थिर API कुंजी पेश नहीं कर सकते, जैसा कि OpenAI के दस्तावेज़ में सीधे उल्लेख किया गया है। एक सर्वर जैसे Scrapeless MCP अंत बिंदु, जो x-api-token हेडर पर प्रमाणीकरण करता है और कोई OAuth मेटाडेटा प्रकाशित नहीं करता है, इसलिए इसे ChatGPT कनेक्टर के रूप में जोड़ा नहीं जा सकता — एक GPT क्रिया इसके लिए समर्थित मार्ग है।

प्रश्न: मेरी GPT क्रिया 401 क्यों लौटाती है?

अधिकतर हेडर नाम। API कुंजी ऑथ प्रकार डिफ़ॉल्ट रूप से बेयरर पर सेट होता है, जो Authorization: Bearer <key> भेजता है; Scrapeless x-api-token पढ़ता है। ऑथ प्रकार को कस्टम पर सेट करें और हेडर का नाम x-api-token पर सेट करें। स्कीमा दोनों तरह से मान्य है, इसलिए यह सेटअप के बजाय पहले कॉल पर सतह पर आता है।

प्रश्न: GPT क्रियाओं को किस OpenAPI संस्करण की आवश्यकता है?

उपरोक्त स्कीमा OpenAPI 3.1.0 है और उस विनिर्देशन के खिलाफ मान्य है। दस्तावेज़ को न्यूनतम रखें — एक सर्वर URL, स्पष्ट operationId मान, और कोई $ref अप्रत्यक्षता जो आपको आवश्यक नहीं है — क्योंकि निर्माता का पार्सर अधिक सख्त है और इसकी त्रुटियाँ एक समर्पित वैलिडेटर की तुलना में कम विशिष्ट होती हैं।

प्रश्न: मैं क्रिया को मॉडल के संदर्भ को भरने से कैसे रोकूं?

Markdown लौटाएं। response_type को markdown पर सेट करने से, js_render: true को उसी अनुरोध में रखने से, उसी पृष्ठ की 50,403 वर्णों से 8,676 तक गई, और क्रिया की प्रतिक्रिया बातचीत के संदर्भ बजट से खर्च होती है। स्कीमा को भी संकीर्ण करें: एक ऑपरेशन एक छोटे पैरामीटर सेट के साथ मॉडल को महंगा कॉल बनाने के लिए कम स्थान देता है।

प्रश्न: मेरी outputFormat पैरामीटर ने कुछ क्यों नहीं किया?

क्योंकि यह एक पैरामीटर नहीं है जिसे अभिनेता पढ़ता है। अनुरोध अभी भी HTTP 200 और पूरा HTML लौटाता है — 50,403 वर्ण 8,676 के बजाय। सही कुंजी response_type है, और इसके बगल में js_render: true की आवश्यकता है। अज्ञात कुंजी यहाँ अनदेखी की जाती हैं बजाय इसके कि अस्वीकृत की जाएं, इसलिए जब एक प्रारूप सेटिंग का कोई प्रभाव नहीं दिखाई देता है, तो लौटें जो आकार आया।

प्रश्न: क्या एक क्रिया एक से अधिक Scrapeless क्षमता को प्रकट कर सकती है?

हाँ — उसी दस्तावेज़ में प्रति ऑपरेशन एक पथ और एक operationId जोड़ें। प्रत्येक को संकीर्ण रखें और enum सीमाओं को बनाए रखें, क्योंकि एक स्वतंत्र-टेक्स्ट अभिनेता फ़ील्ड के साथ एकल ऑपरेशन मॉडल को अनुमान लगाने के लिए आमंत्रित करता है। न्यूनतम विशेषाधिकार क्रिया की समीक्षा करना भी बाद में आसान बनाता है।

प्रश्न: क्या यह सामान्य ChatGPT बातचीत में काम करता है या केवल कस्टम GPT में?

क्रियाएँ एक GPT से संबंधित होती हैं जिसे आप कॉन्फ़िगर करते हैं, इसलिए क्षमता उस GPT में रहती है न कि हर बातचीत में। कोई भी जिसे आप इसे साझा करते हैं, उस ऑपरेशन को प्राप्त करता है; चाहे वे अपनी कुंजी प्रदान करें या नहीं, यह इस पर निर्भर करता है कि आपने प्रमाणीकरण को कैसे सेट किया है।