FastMCP बनाम MCP SDK: कौन-सा पाइथन फ़्रेमवर्क चुनें?

आप किसी ट्यूटोरियल से from mcp.server.fastmcp import FastMCP को एक नए प्रोजेक्ट में पेस्ट करते हैं, उसे चलाते हैं और Python एक ModuleNotFoundError के साथ जवाब देता है। आपके सेटअप में कोई गड़बड़ी नहीं है। आधिकारिक SDK ने उस क्लास का नाम बदल दिया, स्वतंत्र FastMCP प्रोजेक्ट अपनी राह पर चलता रहा, और अब दोनों लाइब्रेरी एक ही नाम, एक ही प्रोटोकॉल लेयर और बहुत सारे उलझे हुए डेवलपर साझा करती हैं।

यहाँ छोटा जवाब है। अक्टूबर 2026 तक आधिकारिक mcp पैकेज का वर्ज़न 2.3.0 है और स्वतंत्र fastmcp पैकेज का वर्ज़न 4.0.11। जब आपको सर्वर कंपोज़िशन, प्रॉक्सिंग, OpenAPI इम्पोर्ट, बिल्ट-इन ऑथ प्रोवाइडर और इन-प्रोसेस टेस्ट क्लाइंट चाहिए, तब FastMCP चुनें। जब आपको सबसे छोटी डिपेंडेंसी ट्री, प्रोटोकॉल प्रिमिटिव्स पर सीधा नियंत्रण और अपने कोड और स्पेक के बीच कोई अतिरिक्त फ़्रेमवर्क न चाहिए, तब आधिकारिक MCP SDK चुनें।

💡 त्वरित निर्णय: अगर आप ऐसा Model Context Protocol सर्वर बना रहे हैं जिसे असली यूज़र इस्तेमाल करेंगे और आप पक्के तौर पर नहीं जानते, तो FastMCP से शुरुआत करें। सरल सर्वर के लिए बाद में आधिकारिक SDK पर जाना पाँच मिनट का बदलाव है। उल्टी दिशा में जाने पर वे फ़ीचर दोबारा बनाने पड़ते हैं जो FastMCP आपको मुफ़्त में दे चुका था।

दो लाइब्रेरी एक नाम क्यों साझा करती हैं

FastMCP SDK में कैसे आया

Jeremiah Lowin ने FastMCP इसलिए बनाया ताकि MCP सर्वर लिखना एक सामान्य Python फ़ंक्शन लिखने जैसा लगे। वह हाई-लेवल API इतना अच्छा निकला कि Anthropic के आधिकारिक Python SDK ने 2024 में उसे FastMCP 1.0 के रूप में अपना लिया, जो mcp.server.fastmcp पर है। स्वतंत्र प्रोजेक्ट कभी रुका नहीं। वह अपने पैकेज नाम से लगातार रिलीज़ होता रहा, 3.0 GA, 18 फ़रवरी 2026 को पहुँचा, और Prefect ने उसे कोर इंफ़्रास्ट्रक्चर के रूप में अपनाया तो वह एक निजी GitHub अकाउंट से PrefectHQ/fastmcp रिपॉज़िटरी में चला गया।

आज इसे Jeremiah Lowin और Nate Nowack Apache-2.0 लाइसेंस के तहत मेंटेन करते हैं। प्रोजेक्ट का दावा है कि यह सभी भाषाओं के लगभग 70% MCP सर्वरों को शक्ति देता है। यह आँकड़ा प्रोजेक्ट का खुद का बताया हुआ है, इसलिए इसे थोड़े संदेह के साथ देखें।

SDK v2 में क्या बदला

SDK v2 ने इस बँटवारे को आधिकारिक बना दिया। बंडल की गई FastMCP क्लास अब MCPServer है, और पुराना इम्पोर्ट पाथ पूरी तरह हटा दिया गया:

# SDK v1 (bundled FastMCP, gone in v2)
from mcp.server.fastmcp import FastMCP

# SDK v2
from mcp.server import MCPServer

# Standalone FastMCP
from fastmcp import FastMCP

प्रॉम्प्ट कॉपी करें

अगर आपको पुराना व्यवहार चाहिए, तो v1 लाइन मेंटेनेंस मोड में है। उसे uv add "mcp[cli]<2" से इंस्टॉल करें।

आप प्रोटोकॉल के दो प्रतिस्पर्धी इम्प्लीमेंटेशन के बीच नहीं चुन रहे हैं। FastMCP 4 उसी SDK v2 प्रोटोकॉल लेयर पर बना है, इसलिए असली सवाल यह है कि उसके ऊपर आप कितना फ़्रेमवर्क चाहते हैं।

आमने-सामने: त्वरित तुलना

ज़्यादातर प्रोजेक्ट जिन बातों पर तय होते हैं, उन पर ये दोनों एक-दूसरे से कैसे तुलना करते हैं:

इंस्टॉल साइज़ के आँकड़े 5 अक्टूबर 2026 को प्रकाशित एक साइड-बाय-साइड टेस्ट से लिए गए हैं, इसलिए प्लेटफ़ॉर्म और एक्स्ट्रा के हिसाब से आपके नंबर बदलेंगे।

दोनों लाइब्रेरी में न्यूनतम सर्वर

पहले दिन का कोड लगभग एक जैसा है। दोनों लाइब्रेरी में टाइप हिंट JSON Schema बन जाते हैं, और डॉकस्ट्रिंग टूल के विवरण में बदल जाते हैं। यह आधिकारिक SDK वाला वर्ज़न है:

from mcp.server import MCPServer

mcp = MCPServer("Demo")

@mcp.tool()
def add(a: int, b: int) -> int:
    """Add two numbers."""
    return a + b

@mcp.resource("greeting://{name}")
def greeting(name: str) -> str:
    """Greet someone by name."""
    return f"Hello, {name}!"

प्रॉम्प्ट कॉपी करें

और यह FastMCP वाला वर्ज़न है:

from fastmcp import FastMCP

mcp = FastMCP("Demo")

@mcp.tool
def add(a: int, b: int) -> int:
    """Add two numbers."""
    return a + b

@mcp.resource("greeting://{name}")
def greeting(name: str) -> str:
    """Greet someone by name."""
    return f"Hello, {name}!"

if __name__ == "__main__":
    mcp.run()

प्रॉम्प्ट कॉपी करें

SDK के cli एक्स्ट्रा के साथ आप पहला वाला mcp dev server.py का इस्तेमाल करके चला सकते हैं। दूसरा सिर्फ़ सादे python server.py से चलता है।

छोटे सिंटैक्स फ़र्क जो परेशान करते हैं

ज़्यादातर माइग्रेशन बग ऐसी ही छोटी बातों से आते हैं:

• पैरेंथीसिस: SDK का MCPServer @mcp.tool() माँगता है। खाली @mcp.tool एक TypeError उठाता है। FastMCP दोनों स्वीकार करता है।
• ट्रांसपोर्ट का नाम: SDK उसे "streamable-http" कहता है। FastMCP उसे "http" कहता है।
• ट्रांसपोर्ट सेटिंग: SDK v2 में होस्ट और पोर्ट कंस्ट्रक्टर से हटकर run() कॉल में चले गए हैं।
• कॉन्टेक्स्ट प्रॉपर्टी: SDK में ctx.mcp_server FastMCP में ctx.fastmcp बन जाता है, और ctx.log(level, data) बन जाता है ctx.log(message, level=...)।

आधिकारिक SDK सबसे अच्छा क्या करता है

हल्की डिपेंडेंसी का फ़ुटप्रिंट

आधिकारिक पैकेज छोटा इंस्टॉल है। अक्टूबर 2026 के मापों में mcp 2.3.0 ने site-packages में 36 पैकेज और लगभग 41 MB जोड़े, जबकि fastmcp 4.0.11 ने 66 पैकेज और लगभग 65 MB। यह अंतर एक्स्ट्रा की कीमत है: ऑथ प्रोवाइडर, OpenAPI टूलिंग, प्रॉक्सिंग और क्लाइंट लाइब्रेरी।

व्यवहार में यह क्यों मायने रखता है:

• ऑडिट करने के लिए कम पैकेज, जब सिक्योरिटी टीम हर ट्रांज़िटिव डिपेंडेंसी की समीक्षा करती है।
• छोटे कंटेनर इमेज, उन सर्वरों के लिए जो कई छोटे रेप्लिका में चलते हैं।
• अपग्रेड का कम दायरा, जब किसी कमज़ोरी का पता ऐसे कोड में चले जिसे आपका सर्वर कभी इस्तेमाल ही नहीं करता।

कोल्ड इम्पोर्ट टाइम कमज़ोर तर्क है। वही माप एक ही मशीन पर अलग-अलग रन में काफ़ी बदलते रहे, इसलिए स्टार्टअप के कुछ सौ मिलीसेकंड के लिए लाइब्रेरी न चुनें।

प्रोटोकॉल पर सीधा नियंत्रण

आधिकारिक SDK में सरल MCPServer क्लास के साथ एक लो-लेवल Server क्लास भी है। v2 में हर हैंडलर एक ही आकार का होता है, async (ctx, params) -> result, जिसमें कोई डेकोरेटर नहीं और कोई अपने-आप रैपिंग नहीं:

from mcp.server import Server, ServerRequestContext
from mcp.types import CallToolRequestParams, CallToolResult, TextContent

async def call_tool(ctx: ServerRequestContext, params: CallToolRequestParams) -> CallToolResult:
    return CallToolResult(content=[TextContent(type="text", text="ok")])

server = Server("Bookshop", on_call_tool=call_tool)

प्रॉम्प्ट कॉपी करें

अनुरोध की हैंडलिंग आप खुद लिखते हैं, यानी ज़्यादा टाइपिंग और ज़्यादा नियंत्रण। SDK v2 में प्रोटोकॉल-लेवल टूल भी आते हैं, जिन तक आप यहाँ सबसे सीधे पहुँचते हैं:

• Resolve और Elicit: एक टूल पैरामीटर जिसे आपका लिखा फ़ंक्शन भरता है, वह मॉडल से छिपा रहता है, और वह कॉल के बीच में रुककर यूज़र से सवाल पूछ सकता है।
• फ़र्स्ट-क्लास Client: from mcp import Client कनेक्शन की बातचीत आपके लिए करता है, बिना नेस्टेड ClientSession और मैनुअल इनिशियलाइज़ेशन के।
• बिल्ट-इन OpenTelemetry: हर अनुरोध मिडलवेयर से होकर ट्रेस होता है।
• रिस्पॉन्स कैशिंग: सर्वर पर cache_hints और क्लाइंट में कैश सपोर्ट।
• डुअल प्रोटोकॉल सपोर्ट: एक ही डिप्लॉयमेंट 2025 और 2026 दोनों प्रोटोकॉल रिवीज़न के क्लाइंट्स को सेवा दे सकता है।

2026-07-28 प्रोटोकॉल रिवीज़न Streamable HTTP पर initialize हैंडशेक और सेशन ID हटा देता है, ताकि एक सादा लोड बैलेंसर अनुरोधों को स्टेटलेस रेप्लिका में बाँट सके। दोनों लाइब्रेरी एक ही प्रोटोकॉल लेयर पर हैं, लेकिन उसे सीधे कॉन्फ़िगर करने के लिए SDK ही वह जगह है।

FastMCP ऊपर से क्या जोड़ता है

FastMCP का वादा सीधा है: जो चीज़ें आप सर्वर के आसपास वैसे भी लिखते हैं, वे पहले से लिखी मिलें।

कंपोज़िशन और प्रॉक्सिंग

FastMCP एक सर्वर को दूसरे के अंदर माउंट कर सकता है, ताकि weather सर्वर और billing सर्वर अलग-अलग मॉड्यूल में रहें और फिर भी पाथ प्रीफ़िक्स के साथ एक ही एंडपॉइंट के रूप में दिखें। यह किसी तीसरे-पक्ष के MCP सर्वर को प्रॉक्सी भी कर सकता है, जिससे आप मौजूदा सर्वर को अपने ऑथ के साथ रैप कर सकते हैं। आधिकारिक SDK में इनमें से कोई भी बिल्ट-इन फ़ीचर नहीं है।

वर्ज़न 3.0 ने इसे प्रोवाइडर के आधार पर दोबारा बनाया। टूल्स अब एक ही फ़ाइल में रहने की मजबूरी नहीं रखते: एक FileSystemProvider उन्हें एक डायरेक्टरी में खोजता है और बदलने पर उन्हें दोबारा लोड करता है।

OpenAPI इम्पोर्ट और ऑथ प्रोवाइडर

अगर आपकी कंपनी पहले से REST API चलाती है, तो OpenAPIProvider OpenAPI स्पेक या FastAPI ऐप को हर एंडपॉइंट हाथ से दोबारा लिखे बिना MCP टूल्स में बदल देता है।

ऑथ के साथ भी यही होता है। FastMCP SDK के तीन अलग पैरामीटर (token_verifier, auth_server_provider और auth=AuthSettings) को एक auth= प्रोवाइडर में समेट देता है, जिसमें JWT, OAuth, GitHub और Google के लिए बिल्ट-इन सपोर्ट है। GitHub लॉगिन जोड़ना एक वीकेंड प्रोजेक्ट की जगह कॉन्फ़िगरेशन का एक विकल्प बन जाता है। टूल्स ctx.sample() के ज़रिए क्लाइंट के LLM से मदद भी माँग सकते हैं।

बिना नेटवर्क के टेस्टिंग

FastMCP का Client सीधे सर्वर ऑब्जेक्ट स्वीकार करता है, इसलिए टेस्ट बिना पोर्ट, बिना सबप्रोसेस और बिना फ़्लेकी टाइमआउट के इन-प्रोसेस चलता है:

import asyncio
from fastmcp import Client, FastMCP

mcp = FastMCP("Demo")

@mcp.tool
def add(a: int, b: int) -> int:
    return a + b

async def main():
    async with Client(mcp) as client:
        result = await client.call_tool("add", {"a": 2, "b": 3})
        print(result.data)  # 5

asyncio.run(main())

प्रॉम्प्ट कॉपी करें

इन-प्रोसेस टेस्टिंग FastMCP के अपने माइग्रेशन नोट्स में गिनाए गए फ़ायदों में से एक है, और इससे तेज़ pytest सूट बनाना आसान हो जाता है।

दोनों की कमियाँ कहाँ हैं

कोई भी चुनाव मुफ़्त नहीं है। दोनों के साथ ऐसा बिल आता है जो बाद में आता है। FastMCP चुनने वाली टीमें वर्ज़न की उथल-पुथल और डिपेंडेंसी की बड़ी गिनती से कीमत चुकाती हैं, और SDK चुनने वाली टीमें वह कोड खुद लिखकर कीमत चुकाती हैं।

FastMCP तेज़ी से चलता है

FastMCP फ़रवरी 2026 के 3.0 GA से अक्टूबर तक 4.0.11 पर पहुँच गया, इसलिए उम्मीद रखें कि मेजर वर्ज़न जल्दी-जल्दी आएँगे। अपनी प्रोजेक्ट फ़ाइल में रेंज पिन करें, जैसे fastmcp>=4,<5, और हर बदलाव से पहले रिलीज़ नोट्स पढ़ें।

इसमें SDK से लगभग 30 ज़्यादा पैकेज भी आते हैं। Prefect डिप्लॉयमेंट और एक्सेस कंट्रोल के लिए Horizon नाम का होस्टेड प्लेटफ़ॉर्म बेचता है। लाइब्रेरी खुद Apache-2.0 है और जहाँ भी Python चल सके, वहाँ चलती है।

SDK v2 पुराने कोड को तोड़ता है

अगर आप v1 सर्वर अपग्रेड कर रहे हैं, तो असली समय का बजट रखें। v2 रिलीज़ नोट्स में ये ब्रेकिंग बदलाव दर्ज हैं:

• WebSocket ट्रांसपोर्ट (mcp[ws]) हटा दिया गया।
• प्रयोगात्मक Tasks API हटा दिया गया और उसे एक एक्सटेंशन में ले जाया गया।
• McpError अब MCPError है, और टूल के अंदर उठाया गया MCPError एक प्रोटोकॉल एरर बन जाता है, जिसे मॉडल कभी नहीं देखता।
• mount_path पैरामीटर हट गया है।
• सिंक हैंडलर अब इवेंट लूप की जगह एक वर्कर थ्रेड पर चलते हैं।
• Streamable HTTP पर lifespan हर सेशन के बजाय स्टार्टअप पर एक बार चलता है।
• HTTP क्लाइंट httpx से httpx2 में चला गया है।

मिनटों में सही चुनें

फ़ीचर की खोज छोड़ें और अपनी स्थिति को इस तालिका से मिलाएँ:

एक तीन लोगों की टीम की कल्पना करें जो चाहती है कि एक AI असिस्टेंट उसके आंतरिक ऑर्डर API को पढ़े। OpenAPI स्पेक पहले से मौजूद हो, तो OpenAPIProvider एंडपॉइंट-दर-एंडपॉइंट का ज़्यादातर काम हटा देता है, और अकेला auth= प्रोवाइडर कंपनी लॉगिन सँभाल लेता है। अब एक प्लेटफ़ॉर्म टीम की कल्पना करें जो एक ऑडिट किया हुआ गेटवे बना रही है, जिसे सख़्त डिपेंडेंसी समीक्षा पास करनी है। वह टीम SDK पर पहुँचती है और उन लो-लेवल हैंडलर्स को पाती है जिनकी उसे ज़रूरत है। किसी टीम ने गलती नहीं की। दोनों की शुरुआत अलग-अलग बाधाओं से हुई।

FastMCP कब चुनें

• आप ऐसी चीज़ भेज रहे हैं जिसमें यूज़र लॉगिन करेंगे।
• आप तीन की जगह एक auth= सेटिंग चाहते हैं।
• आपको उम्मीद है कि एक सर्वर से कई सर्वर तक बढ़ेंगे।
• आप छोटा @mcp.tool डेकोरेटर और तेज़ इन-प्रोसेस टेस्ट पसंद करते हैं।

आधिकारिक SDK कब चुनें

• आपको सबसे कम डिपेंडेंसी और सबसे छोटी इमेज चाहिए।
• आपको कच्चे अनुरोध और रिस्पॉन्स खुद सँभालने हैं।
• आपकी टीम MCP प्रोजेक्ट के रेफ़रेंस इम्प्लीमेंटेशन को मानक मानती है।
• आपको OpenTelemetry और Resolve या Elicit सपोर्ट सीधे बेस पैकेज से चाहिए।

बाद में एक से दूसरे पर जाना

दोनों लाइब्रेरी एक प्रोटोकॉल लेयर साझा करती हैं, इसलिए उनके बीच जाना ज़्यादातर यांत्रिक काम है। SDK से FastMCP पर जाना कुछ ऐसा दिखता है:

- from mcp.server import MCPServer
+ from fastmcp import FastMCP

- mcp = MCPServer("orders")
+ mcp = FastMCP("orders")

- @mcp.tool()
+ @mcp.tool

प्रॉम्प्ट कॉपी करें

फिर अपनी run() कॉल में "streamable-http" को "http" से बदलें, ctx.mcp_server का नाम ctx.fastmcp करें, और तीनों ऑथ सेटिंग को एक प्रोवाइडर में मिला दें। उल्टी दिशा में जाने पर ये बदलाव पलटें और कंपोज़िशन, प्रॉक्सिंग व OpenAPI इम्पोर्ट की जगह अपना कोड लिखने की योजना बनाएँ।

हर चरण के बाद अपने टेस्ट चलाएँ। अगर आपने उन्हें इन-प्रोसेस क्लाइंट से लिखा है, तो पूरी जाँच में सेकंड लगते हैं।

Picasso IA के साथ अपना खुद का बनाएँ

MCP सर्वर उतना ही उपयोगी होता है जितना उसके टूल्स के पीछे का काम। Picasso IA इमेज जनरेशन, इमेज एडिटिंग और वीडियो जनरेशन के लिए एक MCP कनेक्टर और डेवलपर API देता है, ताकि Claude Desktop जैसा क्लाइंट ऐसे टूल्स के ज़रिए विज़ुअल बना सके जिन्हें आपको खुद नहीं बनाना पड़ा। ये काम एसिंक्रोनस होते हैं: आप एक जॉब सबमिट करते हैं, फिर परिणाम के लिए पोल करते हैं। यह सबमिट-फिर-पोल पैटर्न आपके अपने सर्वरों के लिए भी काम का है, जिसमें एक टूल जॉब ID लौटाता है और दूसरा टूल उसकी स्थिति जाँचता है।

PicassoIA पर अपना सर्वर ड्राफ़्ट करें

दोनों में से किसी भी वर्ज़न का पहला ड्राफ़्ट एक LLM से लिखवाया जा सकता है। Claude Sonnet 5 के साथ तेज़ तरीका यह है, जो कोडिंग कार्यों के लिए बनाया गया मॉडल है:

1. PicassoIA पर Claude Sonnet 5 पेज खोलें।
2. ज़रूरी प्रॉम्प्ट फ़ील्ड भरें, जैसे: "Write an MCP server in Python using FastMCP with two tools, one that adds numbers and one that fetches a weather summary, plus a pytest file using the in-process client."
3. effort सेट करें: छोटे बदलावों के लिए इसे low पर रहने दें, या किसी जटिल मल्टी-फ़ाइल बग के लिए बढ़ाएँ।
4. पूरी सर्वर फ़ाइल के लिए max tokens को डिफ़ॉल्ट 8,192 पर रखें, और कोडिंग स्टाइल एक बार तय करने के लिए system prompt इस्तेमाल करें।
5. अगर आपके पास कोई इमेज है, जैसे किसी एरर का स्क्रीनशॉट, तो उसे अटैच करें, फिर जनरेट करें और कोड को अपने प्रोजेक्ट में पेस्ट करें।

एक ही अनुरोध में दोनों वर्ज़न माँगें और उनका अंतर खुद देखें। अगर आप कोड पर दूसरी राय चाहते हैं, तो GPT 5.6 Sol जटिल कोडिंग कार्यों के लिए बना है और अच्छा रिव्यूअर साबित होता है।

एक बार आपका सर्वर चल जाए, तो उसे कुछ मज़ेदार काम दें। Picasso IA खोलें, इमेज और वीडियो मॉडल आज़माएँ, और देखें कि कुछ अच्छे लिखे प्रॉम्प्ट क्या बनाते हैं। फिर अपने पसंदीदा टूल को अपने MCP सर्वर से जोड़ें और अपने अगले प्रोजेक्ट को उसके अपने विज़ुअल बनाने दें। आपकी पहली इमेज बस एक प्रॉम्प्ट दूर है।