लाइव वेब डेटा के लिए MCP टूल बनाएँ

01जब असिस्टेंट डेटा माँगता है तो क्या होता है

• आपका ऐप https://api.everydata.io/mcp से जुड़ता है और पूछता है कि कौन-से टूल हैं – जैसे amazon_product_by_asin, amazon_search, amazon_reviews, walmart_search, zalando_search, otto_search, youtube_video, youtube_comments और yahoo_quotes।
• जब किसी सवाल को लाइव डेटा चाहिए, तो मॉडल एक टूल चुनता है और उसके इनपुट भरता है, जैसे कोई ASIN या वीडियो ID।
• everydata.io पेज लोड करता है, डेटा लौटाता है, और मॉडल उसी से जवाब देता है।
• आपकी API key हर रिक्वेस्ट के साथ जाती है, इसलिए हर tool call एक सामान्य API रिक्वेस्ट की तरह आपके प्लान में गिनी जाती है – उन्हीं weights के साथ। हमारी ओर से विफल कॉल का शुल्क नहीं लगता।

दो टूल बाक़ी सब कवर करते हैं: list_endpoints हर डेटा endpoint को उसके इनपुट के साथ दिखाता है, और call_endpoint उनमें से किसी को भी कॉल करता है। account_quota मॉडल को बताता है कि आपके मासिक quota में कितना बचा है। टूल की पूरी लिस्ट MCP सर्वर docs में है।

02Claude Desktop जोड़ें

सबसे तेज़ तरीका: Claude Desktop (या claude.ai) में Settings → Connectors → Add custom connector खोलें और https://api.everydata.io/mcp डालें। Claude आपको everydata.io पर भेजता है, आप अपने ई-मेल लिंक से साइन इन करते हैं और एक्सेस मंज़ूर करते हैं – कॉपी करने को कोई key नहीं। इसकी जगह API key इस्तेमाल करना पसंद है? mcp-remote से जोड़ें, एक छोटा ब्रिज जिसे Claude Desktop आपकी मशीन पर चलाता है और जो हर रिक्वेस्ट – आपकी key के साथ – होस्टेड सर्वर को भेजता है, जैसा नीचे दिखाया गया है।

Settings → Developer → Edit config खोलें, नीचे की एंट्री claude_desktop_config.json में जोड़ें, अपनी key Bearer के बाद डालें और Claude Desktop दोबारा शुरू करें।

{
  "mcpServers": {
    "everydata": {
      "command": "npx",
      "args": [
        "-y",
        "mcp-remote",
        "https://api.everydata.io/mcp",
        "--header",
        "Authorization:${EVERYDATA_AUTH}"
      ],
      "env": {
        "EVERYDATA_AUTH": "Bearer ds_your_key"
      }
    }
  }
}

key env में है और हेडर में कोलन के बाद जानबूझकर कोई स्पेस नहीं है: Windows पर Claude Desktop args के अंदर स्पेस को सही तरीके से आगे नहीं भेजता, और mcp-remote ${EVERYDATA_AUTH} को env से भरता है। यही एंट्री macOS पर भी काम करती है।

रीस्टार्ट के बाद ऐसा सवाल पूछें जिसे लाइव डेटा चाहिए (नीचे का टेस्ट देखें) – Claude everydata टूल इस्तेमाल करने की अनुमति माँगता है। अगर कोई टूल नहीं दिखता, तो Settings → Developer दिखाता है कि ब्रिज चल रहा है या नहीं और उसकी आख़िरी एरर क्या थी। Node.js का न होना (npx not found) सबसे आम वजह है।

03Claude Code जोड़ें

Claude Code सीधे remote MCP सर्वर से बात करता है। एक कमांड आपकी key के साथ सर्वर रजिस्टर करती है:

export EVERYDATA_KEY="ds_your_key"
claude mcp add --transport http everydata https://api.everydata.io/mcp \
  --header "Authorization: Bearer $EVERYDATA_KEY"

# check that it is connected
claude mcp list

कमांड चलाने पर आपका shell $EVERYDATA_KEY भरता है, और Claude Code हेडर को अपनी सेटिंग्स में सेव करता है। सर्वर को सिर्फ़ मौजूदा प्रोजेक्ट के बजाय हर प्रोजेक्ट में इस्तेमाल करने के लिए --scope user जोड़ें। Claude Code के अंदर /mcp कनेक्शन और उसके टूल दिखाता है।

04इसे OpenAI या Anthropic API से इस्तेमाल करें

अगर आप अपना एजेंट बनाते हैं, तो दोनों API आपके लिए remote MCP सर्वर कॉल कर सकते हैं: आप पता और key देते हैं, और प्रोवाइडर टूल लिस्ट करता है, उन्हें कॉल करता है और नतीजे मॉडल को देता है। आपको ख़ुद कोई टूल कोड नहीं लिखना पड़ता। दोनों उदाहरण आपकी key EVERYDATA_KEY environment variable से पढ़ते हैं।

OpenAI Responses API – headers में key के साथ एक mcp टूल:

import os

from openai import OpenAI

client = OpenAI()

resp = client.responses.create(
    model="gpt-6-astra",
    input="How many views does the Despacito video on YouTube have right now?",
    tools=[{
        "type": "mcp",
        "server_label": "everydata",
        "server_url": "https://api.everydata.io/mcp",
        "headers": {"Authorization": f"Bearer {os.environ['EVERYDATA_KEY']}"},
        "require_approval": "never",
    }],
)
print(resp.output_text)

Anthropic Messages API – MCP connector सर्वर को mcp_servers में लेता है, tools में उससे मेल खाता mcp_toolset, और mcp-client-2025-11-20 beta हेडर (SDK इसे betas से सेट करता है):

import os

import anthropic

client = anthropic.Anthropic()

resp = client.beta.messages.create(
    model="claude-opus-5",
    max_tokens=1024,
    messages=[{"role": "user", "content": "How many views does the Despacito video on YouTube have right now?"}],
    mcp_servers=[{
        "type": "url",
        "url": "https://api.everydata.io/mcp",
        "name": "everydata",
        "authorization_token": os.environ["EVERYDATA_KEY"],  # sent as "Authorization: Bearer …"
    }],
    tools=[{"type": "mcp_toolset", "mcp_server_name": "everydata"}],
    betas=["mcp-client-2025-11-20"],
)
print(resp.content[-1].text)

ChatGPT ऐप में URL https://api.everydata.io/mcp के साथ एक custom connector जोड़ें (विकल्प आपके ChatGPT प्लान पर निर्भर करता है)। आप everydata.io में साइन इन करेंगे और एक्सेस मंज़ूर करेंगे; आप इसे कभी भी अपने डैशबोर्ड में API keys के तहत रद्द कर सकते हैं।

05आज़माएँ: एक सवाल, एक tool call

अपने असिस्टेंट से पूछें “YouTube पर Despacito वीडियो पर अभी कितने व्यू हैं?”। मॉडल youtube_video चुनता है और वीडियो ID भेजता है:

{
  "name": "youtube_video",
  "arguments": { "id": "kJQP7kiw5Fk" }
}

टूल वही जवाब लौटाता है जो REST endpoint, और असिस्टेंट मौजूदा आँकड़ों के साथ जवाब देता है। छोटा किया गया डॉक्यूमेंटेड उदाहरण:

{
  "responseStatus": "PAGE_FOUND",
  "responseMessage": "Page successfully found!",
  "videoId": "kJQP7kiw5Fk",
  "title": "Luis Fonsi - Despacito ft. Daddy Yankee",
  "channelName": "LuisFonsiVEVO",
  "viewCount": 9125159593,
  "likeCount": 56673581,
  "commentCount": 4300000,
  "publishedAt": "2017-01-12T21:00:02-08:00"
}

यह कॉल एक रिक्वेस्ट गिनी जाती है। बहुत लंबे जवाब – कई रिव्यू या सर्च रिज़ल्ट – मॉडल के लिए छोटे कर दिए जाते हैं, और टूल उसे कम माँगने को कहता है, जैसे छोटा पेज।

06जब tool call विफल हो

एरर मॉडल के पास टेक्स्ट में स्टेटस कोड के साथ विफल tool call के रूप में लौटती हैं, इसलिए असिस्टेंट आमतौर पर बता सकता है कि क्या गड़बड़ हुई।

• 401 – key या साइन-इन ग़ायब है या ग़लत है। जाँचें कि हेडर Authorization: Bearer ds_… है (या key को x-api-key के रूप में भेजें)। connector साइन-इन के साथ, डिस्कनेक्ट करके दोबारा जोड़ें।
• 429 – आपके प्लान के लिए एक साथ बहुत ज़्यादा रिक्वेस्ट। मैसेज में दिए सेकंड तक रुकें और दोबारा कोशिश करें। 403 का मतलब है कि इस महीने का quota ख़त्म हो गया; account_quota दिखाता है कि क्या बचा है।
• 503 या कोई दूसरा 5xx – साइट अभी लोड नहीं हो सकी। इन कॉल का शुल्क नहीं लगता; बस थोड़ी देर बाद फिर पूछें।
• टाइमआउट – एक tool call को 50 सेकंड मिलते हैं। धीमे पेज (कई रिव्यू, बड़ी सर्च) में ज़्यादा समय लग सकता है; तब कॉल विफल होती है, शुल्क नहीं लगता, और छोटी रिक्वेस्ट आमतौर पर काम करती है।

हर प्लान की सीमाएँ Limits & quota में हैं।

07विकल्प: अपना MCP सर्वर चलाएँ

अगर आप ठीक-ठीक तय करना चाहते हैं कि मॉडल कौन-से endpoint और फ़ील्ड देखे, तो आप आधिकारिक MCP Python SDK से ख़ुद एक छोटा सर्वर लिख सकते हैं (pip install "mcp[cli]>=2" requests, या दोनों uv से इंस्टॉल करवाएँ)। हर टूल एक फ़ंक्शन है: एक everydata.io रिक्वेस्ट, कुछ चुने हुए फ़ील्ड। docstring वह है जिसे मॉडल पढ़ता है।

"""A minimal MCP server that gives AI assistants live product and video data from everydata.io."""
import os

import requests
from mcp.server.mcpserver import MCPServer

API = "https://api.everydata.io"
KEY = os.environ["EVERYDATA_API_KEY"]

mcp = MCPServer("everydata")


def _get(path: str, params: dict) -> dict:
    """One everydata.io request. Errors come back as data, so the assistant can explain them."""
    try:
        resp = requests.get(f"{API}{path}", params=params, headers={"x-api-key": KEY}, timeout=60)
    except requests.RequestException as exc:
        return {"error": "network", "detail": str(exc)[:300]}
    if resp.status_code >= 400:  # e.g. 429 = too many requests at once, 5xx = page could not be loaded
        return {"error": resp.status_code, "detail": resp.text[:300]}
    return resp.json()


def _pick(data: dict, keys: tuple) -> dict:
    return data if "error" in data else {k: data.get(k) for k in keys}


@mcp.tool()
def amazon_product(asin: str, domainCode: str = "com") -> dict:
    """Live title, price, list price, availability and rating of an Amazon product.
    asin is the 10-character product ID; domainCode is the marketplace (com, de, co.uk …).
    A price of 0 means the page shows no price right now."""
    data = _get("/amz/amazon-lookup-product-by-asin", {"asin": asin, "domainCode": domainCode})
    return _pick(data, ("productTitle", "asin", "price", "retailPrice", "currency",
                        "productRating", "countReview", "warehouseAvailability"))


@mcp.tool()
def zalando_search(keyword: str, page: int = 1) -> dict:
    """Search the Zalando shop (zalando.de by default) and return up to 10 products with price and link."""
    data = _get("/zal/zalando-search-by-keyword", {"keyword": keyword, "page": page})
    if "error" in data:
        return data
    keep = ("productDescription", "manufacturer", "price", "retailPrice", "currency", "dpUrl")
    return {"results": [{k: p.get(k) for k in keep} for p in data.get("searchProductDetails", [])[:10]]}


@mcp.tool()
def youtube_video(video: str) -> dict:
    """Current view, like and comment counts of a YouTube video. video is the video ID or its URL."""
    data = _get("/ytb/youtube-video-details", {"id": video})
    return _pick(data, ("videoId", "title", "channelName", "viewCount", "likeCount", "commentCount", "publishedAt"))


if __name__ == "__main__":
    mcp.run()  # the assistant app starts this script and talks to it directly

Claude Desktop स्क्रिप्ट को ख़ुद शुरू करता है। पूरे paths इस्तेमाल करें (which uv दिखाता है कि uv कहाँ है), क्योंकि Claude Desktop आपके टर्मिनल से शुरू नहीं होता:

{
  "mcpServers": {
    "everydata-local": {
      "command": "/Users/you/.local/bin/uv",
      "args": ["run", "--with", "mcp[cli]>=2", "--with", "requests",
               "python", "/Users/you/everydata-mcp/server.py"],
      "env": { "EVERYDATA_API_KEY": "ds_your_key" }
    }
  }
}

Claude Code में:

claude mcp add everydata-local --env EVERYDATA_API_KEY=ds_your_key -- uv run --with "mcp[cli]>=2" --with requests python /absolute/path/to/server.py