BroadRouter

OpenAI-कम्पैटिबल मॉडल के साथ MCP सर्वर (किसी भी प्रोवाइडर पर)

BroadNet Inference टीम · 4 मिनट में पढ़ें · प्रकाशित · अपडेट किया गया

MCP मॉडल से स्वतंत्र है। आपके ऐप का MCP क्लाइंट हर सर्वर के टूल की सूची बनाता है, उन्हें मॉडल को साधारण फ़ंक्शन-कॉलिंग टूल की तरह देता है, और मॉडल के माँगने पर tools/call चलाता है। भरोसेमंद टूल कॉलिंग वाला कोई भी OpenAI-कम्पैटिबल मॉडल MCP सर्वर इस्तेमाल कर सकता है। इन्हें Cline, Continue, opencode या n8n में कॉन्फ़िगर करें, या लगभग 40 लाइन के Python से जोड़ें।

Model Context Protocol (MCP) एजेंट को टूल तक पहुँचने का एक मानक तरीक़ा देता है: GitHub, डेटाबेस, फ़ाइल सिस्टम, ब्राउज़र। MCP के कई ट्यूटोरियल Claude या GPT मानकर चलते हैं। आपको इन दोनों में से किसी की ज़रूरत नहीं। यह पोस्ट बताती है कि MCP टूल कॉलिंग सपोर्ट करने वाले किसी भी OpenAI-कम्पैटिबल मॉडल के साथ क्यों चलता है, डेवलपर जो क्लाइंट असल में इस्तेमाल करते हैं उनमें इसे कैसे सेट करें, और अपने कोड में MCP को ओपन मॉडल से कैसे जोड़ें।

MCP किसी भी मॉडल के साथ क्यों चलता है?

MCP आपके ऐप्लिकेशन और टूल सर्वर के बीच बैठता है, आपके ऐप्लिकेशन और मॉडल के बीच नहीं। MCP की आर्किटेक्चर डॉक्स तीन भूमिकाएँ बताती हैं:

  • होस्ट: AI ऐप्लिकेशन, जैसे कोई एडिटर एक्सटेंशन या आपकी स्क्रिप्ट।
  • क्लाइंट: एक कनेक्शन, जो होस्ट हर MCP सर्वर से रखता है।
  • सर्वर: एक प्रोग्राम जो टूल, रिसोर्स और प्रॉम्प्ट देता है, लोकल रूप से stdio पर या रिमोट रूप से Streamable HTTP पर।

डॉक्स साफ़ कहती हैं: MCP “does not dictate how AI applications use LLMs or manage the provided context.” (अनुवाद: यह तय नहीं करता कि AI ऐप्लिकेशन LLM कैसे इस्तेमाल करें या दिए गए कॉन्टेक्स्ट को कैसे सँभालें।) होस्ट tools/list से हर सर्वर के टूल की सूची लेता है, उन्हें एक रजिस्ट्री में मिलाता है जिसे मॉडल देख सके, और जब मॉडल कोई टूल माँगता है, तो होस्ट सही सर्वर को tools/call भेजता है।

OpenAI-कम्पैटिबल API पर “मॉडल देख सके” का मतलब है कि टूल साधारण tools ऐरे में जाते हैं। MCP टूल में पहले से एक नाम, एक description और एक inputSchema होता है, जो फ़ंक्शन परिभाषा से एक-एक करके मेल खाता है। मॉडल को कभी पता नहीं चलता कि MCP शामिल है। उसे बस भरोसेमंद टूल कॉलिंग चाहिए।

MCP के लिए कौन सा मॉडल इस्तेमाल करें?

BroadNet पर मॉडल टूल कॉलिंग दर्ज कॉन्टेक्स्ट MCP के लिए उपयुक्तता
GLM 5.3 हाँ 1,048,576 कई सर्वर के लिए अच्छा डिफ़ॉल्ट
Qwen3.8 27B हाँ 262,144 अच्छा, साथ में इमेज इनपुट
DeepSeek V4.1 Flash लिस्टेड नहीं 1,048,576 पहले टेस्ट करें; इमेज इनपुट
Gemma 4 VL 26B लिस्टेड नहीं 32,768 सुझाया नहीं जाता

टूल चलाने वाले दोनों मॉडल की आमने-सामने तुलना के लिए देखें GLM 5.3 बनाम Qwen3.8 27B। कॉन्टेक्स्ट लोगों की उम्मीद से ज़्यादा मायने रखता है। हर MCP टूल स्कीमा हर कॉल के साथ जाता है। opencode की डॉक्स कहती हैं “MCP tools consume model context, so add only the servers you need.” (अनुवाद: MCP टूल मॉडल का कॉन्टेक्स्ट खाते हैं, इसलिए सिर्फ़ ज़रूरी सर्वर जोड़ें।) एजेंट टोकन बजट वाली पोस्ट दिखाती है कि इसे कैसे मापें।

आम क्लाइंट में MCP कैसे सेट करें?

क्लाइंट MCP सर्वर कहाँ जाते हैं ट्रांसपोर्ट नोट
Cline MCP Servers पैनल, mcpServers JSON stdio, Streamable HTTP, पुराना SSE रिमोट टाइप "streamableHttp"
Continue config.yaml में mcpServers या .continue/mcpServers/ stdio, sse, streamable-http सिर्फ़ Agent मोड
opencode opencode.jsonc में mcp.servers local, remote सीक्रेट के लिए {env:NAME} इस्तेमाल करें
n8n AI Agent पर MCP Client Tool नोड रिमोट सर्वर एंडपॉइंट (इसकी डॉक्स एक SSE एंडपॉइंट बताती हैं) All, Selected या All Except टूल चुनें
OpenAI Agents SDK Agent पर mcp_servers=[...] stdio, Streamable HTTP, SSE HostedMCPTool नहीं

फिर क्लाइंट के मॉडल को अपने प्रोवाइडर की ओर करें: Cline, Continue और opencode की गाइड BroadNet के लिए मॉडल वाला हिस्सा कवर करती हैं। Continue में tool_use क्षमता याद रखें, वरना Agent मोड उपलब्ध नहीं होगा।

Continue का एक उदाहरण, उसकी डॉक्स से:

mcpServers:
  - name: SQLite MCP
    type: stdio
    command: npx
    args: ["-y", "mcp-sqlite", "/path/to/your/database.db"]

Python में MCP को ओपन मॉडल से कैसे जोड़ें?

अगर आप अपना एजेंट बना रहे हैं, तो यह पुल छोटा है। यह MCP Python SDK का Client (वर्ज़न 2.0 या बाद का; pip install "mcp>=2") इस्तेमाल करता है, जो StdioServerParameters मिलने पर stdio सर्वर शुरू करता है, और BroadNet की ओर किया गया OpenAI SDK:

import asyncio, json, os
from mcp import Client, StdioServerParameters
from mcp.types import TextContent
from openai import OpenAI

llm = OpenAI(base_url="https://inference.broadnet.ai/v1", api_key=os.environ["BROADNET_API_KEY"])
server = StdioServerParameters(command="npx",
    args=["-y", "@modelcontextprotocol/server-filesystem", "."])

async def main(question):
    async with Client(server) as mcp:
        listed = await mcp.list_tools()
        tools = [{"type": "function", "function": {
                    "name": t.name, "description": t.description or "",
                    "parameters": t.input_schema}} for t in listed.tools]
        messages = [{"role": "user", "content": question}]
        for _ in range(8):
            r = llm.chat.completions.create(model="broadnet/glm-5.3",
                    messages=messages, tools=tools, max_tokens=4000)
            msg = r.choices[0].message
            messages.append(msg.model_dump(exclude_none=True))
            if not msg.tool_calls:
                return msg.content
            for call in msg.tool_calls:
                try:
                    res = await mcp.call_tool(call.function.name,
                                              json.loads(call.function.arguments or "{}"))
                    text = "\n".join(b.text for b in res.content if isinstance(b, TextContent))
                    out = f"Error: {text}" if res.is_error else text
                except Exception as e:
                    out = f"Error: {e}"
                messages.append({"role": "tool", "tool_call_id": call.id, "content": out})

print(asyncio.run(main("List the Markdown files here and summarize the README.")))

mcp 1.x में कोई Client क्लास नहीं है: सर्वर को stdio_client(...) से खोलें, उसे ClientSession में लपेटें, initialize() कॉल करें, और camelCase फ़ील्ड inputSchema और isError पढ़ें। तीन बातें मायने रखती हैं:

  1. एरर टूल रिज़ल्ट बनते हैं। MCP SDK टूल की नाकामी एक्सेप्शन उठाने की जगह is_error से बताता है। उन्हें वापस भेजें ताकि मॉडल ख़ुद को ढाल सके। हमारी टूल कॉलिंग गाइड वैलिडेशन और रीट्राई कवर करती है।
  2. लूप को सीमित रखें। यहाँ आठ स्टेप। बड़े नतीजे लौटाने वाले MCP सर्वर कॉन्टेक्स्ट जल्दी भर देते हैं।
  3. टूल फ़िल्टर करें। सिर्फ़ वही टूल दिखाएँ जो काम के लिए ज़रूरी हैं। OpenAI Agents SDK इसके लिए tool_filter देता है, और n8n में Selected और All Except हैं।

इसकी जगह OpenAI Agents SDK इस्तेमाल कर रहे हैं? इसकी MCPServerStdio और MCPServerStreamableHttp क्लास आपके प्रोसेस में चलती हैं। इन्हें कस्टम प्रोवाइडर के साथ जोड़ें, जैसा हमारी Agents SDK गाइड में है। इसका HostedMCPTool OpenAI के Responses API के अंदर चलता है और सिर्फ़ OpenAI मॉडल के साथ काम करता है।

ओपन मॉडल पर MCP में क्या गड़बड़ होती है?

  • बहुत ज़्यादा टूल। मॉडल ग़लत टूल चुनता है या टूल को अनदेखा करता है। चालू सेट छोटा रखें। अपने टूल के लिए JSON schema जनरेटर एक साफ़, सपाट parameters स्कीमा बनाता है।
  • बड़े टूल रिज़ल्ट। पूरी डेटाबेस टेबल लौटाने वाला सर्वर कॉन्टेक्स्ट विंडो से आगे निकल सकता है। सीमा लगाएँ या पेजों में बाँटें।
  • ख़ाली या कटे जवाब। GLM 5.3 और Qwen3.8 27B पहले रीज़निंग करते हैं, और रीज़निंग max_tokens में गिनी जाती है। इसे बढ़ाएँ।
  • भरोसा। MCP सर्वर आपकी मशीन पर कोड चलाते हैं या आपके क्रेडेंशियल से सर्विस कॉल करते हैं। सिर्फ़ भरोसेमंद सर्वर इंस्टॉल करें, और लिखने या पैसे ख़र्च करने वाली कार्रवाइयों की पुष्टि करें।

BroadNet Inference कहाँ फ़िट होता है

BroadNet Inference मॉडल वाला हिस्सा देता है: टूल कॉलिंग के साथ दर्ज GLM 5.3 और Qwen3.8 27B, उसी स्टैंडर्ड chat-completions फ़ॉर्मैट के ज़रिए जिसे ऊपर का हर MCP क्लाइंट इस्तेमाल कर सकता है, प्रॉम्प्ट और आउटपुट पर ज़ीरो डेटा रिटेंशन के साथ। यह आपके लिए MCP सर्वर या होस्टेड टूल नहीं चलाता; यह काम आपका क्लाइंट करता है। दोनों मॉडल की प्रति-टोकन कीमतें प्राइसिंग पेज पर हैं, और key inference.broadnet.ai पर मिलती हैं।

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

क्या मैं Claude या GPT के अलावा किसी मॉडल के साथ MCP इस्तेमाल कर सकता हूँ?

हाँ। MCP आपके ऐप और टूल सर्वर के बीच का प्रोटोकॉल है। ऐप टूल को उस मॉडल के टूल-कॉलिंग फ़ॉर्मैट के ज़रिए देता है जो वह इस्तेमाल करता है। काम करने वाली टूल कॉलिंग वाला कोई भी OpenAI-कम्पैटिबल मॉडल MCP टूल इस्तेमाल कर सकता है।

क्या मॉडल को MCP सपोर्ट करना ज़रूरी है?

नहीं। मॉडल को सिर्फ़ फ़ंक्शन कॉलिंग चाहिए। प्रोटोकॉल का काम, यानी टूल की सूची बनाना और उन्हें कॉल करना, आपके ऐप का MCP क्लाइंट करता है।

कौन से कोडिंग एजेंट कस्टम OpenAI-कम्पैटिबल मॉडल के साथ MCP सपोर्ट करते हैं?

Cline, Agent मोड में Continue और opencode, तीनों में MCP सर्वर और कस्टम OpenAI-कम्पैटिबल मॉडल कॉन्फ़िगर किए जा सकते हैं। Roo Code का आगे का रूप Zoo Code भी MCP सपोर्ट दिखाता है।

MCP सर्वर जोड़ने से मेरा एजेंट धीमा और महँगा क्यों हो जाता है?

हर सर्वर की टूल परिभाषाएँ हर मॉडल कॉल पर प्रॉम्प्ट में जुड़ती हैं। दस सर्वर, हर एक में दर्जन भर टूल, हर स्टेप में हज़ारों इनपुट टोकन जोड़ सकते हैं। सिर्फ़ वही सर्वर चालू करें जो काम के लिए ज़रूरी हैं, या टूल फ़िल्टर करें।

क्या होस्टेड MCP टूल दूसरे प्रोवाइडर के साथ चलते हैं?

OpenAI पर होस्ट होने वाले नहीं। OpenAI Agents SDK की डॉक्स कहती हैं कि HostedMCPTool उन OpenAI मॉडल के साथ चलता है जो Responses API का होस्टेड MCP इंटीग्रेशन सपोर्ट करते हैं। दूसरे प्रोवाइडर के साथ SDK की लोकल MCP सर्वर क्लास इस्तेमाल करें।

Markdown में पढ़ेंChatGPT से पूछेंClaude से पूछेंPerplexity से पूछें