HTTPS स्ट्रीमिंग मॉडल कॉन्टेक्स्ट प्रोटोकॉल (MCP) के साथ

May 19, 2026 · View on GitHub

यह अध्याय Model Context Protocol (MCP) का उपयोग करके HTTPS के साथ सुरक्षित, स्केलेबल और रीयल-टाइम स्ट्रीमिंग को लागू करने के लिए एक व्यापक गाइड प्रदान करता है। यह स्ट्रीमिंग के प्रेरणा, उपलब्ध ट्रांसपोर्ट तंत्र, MCP में स्ट्रीमेबल HTTP को कैसे लागू करें, सुरक्षा की सर्वोत्तम प्रथाओं, SSE से माइग्रेशन, और अपने स्वयं के स्ट्रीमिंग MCP अनुप्रयोगों के निर्माण के लिए व्यावहारिक मार्गदर्शन को कवर करता है।

MCP में ट्रांसपोर्ट तंत्र और स्ट्रीमिंग

यह अनुभाग MCP में उपलब्ध विभिन्न ट्रांसपोर्ट तंत्रों और क्लाइंट और सर्वर के बीच रीयल-टाइम संचार के लिए स्ट्रीमिंग क्षमताओं को सक्षम करने में उनकी भूमिका की जांच करता है।

ट्रांसपोर्ट तंत्र क्या है?

एक ट्रांसपोर्ट तंत्र यह परिभाषित करता है कि क्लाइंट और सर्वर के बीच डेटा कैसे आदान-प्रदान किया जाता है। MCP विभिन्न पर्यावरणों और आवश्यकताओं के अनुसार कई ट्रांसपोर्ट प्रकारों का समर्थन करता है:

  • stdio: मानक इनपुट/आउटपुट, स्थानीय और CLI-आधारित टूल्स के लिए उपयुक्त। सरल लेकिन वेब या क्लाउड के लिए उपयुक्त नहीं।
  • SSE (Server-Sent Events): सर्वर HTTP पर क्लाइंट को रीयल-टाइम अपडेट भेजने की अनुमति देता है। वेब UI के लिए अच्छा, लेकिन मापनीयता और लचीलापन में सीमित। MCP विनिर्देशन 2025-06-18 के अनुसार, स्टैंडअलोन SSE ट्रांसपोर्ट को डिप्रिकेट किया गया है और "Streamable HTTP" ट्रांसपोर्ट द्वारा प्रतिस्थापित किया गया है।
  • Streamable HTTP: आधुनिक HTTP आधारित स्ट्रीमिंग ट्रांसपोर्ट, जो सूचनाएं और बेहतर मापनीयता का समर्थन करता है। अधिकांश उत्पादन और क्लाउड परिदृश्यों के लिए अनुशंसित।

तुलना तालिका

नीचे दी गई तुलना तालिका देखें ताकि इन ट्रांसपोर्ट तंत्रों के बीच अंतर समझ सकें:

Transportरीयल-टाइम अपडेटस्ट्रीमिंगस्केलेबिलिटीउपयोग मामला
stdioनहींनहींकमस्थानीय CLI टूल्स
SSEहाँहाँमध्यमवेब, रीयल-टाइम अपडेट्स
Streamable HTTPहाँहाँउच्चक्लाउड, मल्टी-क्लाइंट

टिप: सही ट्रांसपोर्ट का चयन प्रदर्शन, मापनीयता और उपयोगकर्ता अनुभव को प्रभावित करता है। Streamable HTTP आधुनिक, स्केलेबल, और क्लाउड-तैयार एप्लिकेशन के लिए अनुशंसित है।

पिछले अध्यायों में दिखाए गए stdio और SSE ट्रांसपोर्ट पर ध्यान दें और देखें कि इस अध्याय में Streamable HTTP ट्रांसपोर्ट को कैसे कवर किया गया है।

स्ट्रीमिंग: अवधारणाएं और प्रेरणा

स्ट्रीमिंग की मूलभूत अवधारणाओं और प्रेरणाओं को समझना प्रभावी रीयल-टाइम संचार प्रणाली लागू करने के लिए आवश्यक है।

स्ट्रीमिंग नेटवर्क प्रोग्रामिंग में एक तकनीक है जो डेटा को छोटे, प्रबंधनीय टुकड़ों में या घटनाओं की श्रृंखला के रूप में भेजने और प्राप्त करने की अनुमति देती है, बजाय इसके कि पूरी प्रतिक्रिया के तैयार होने का इंतजार किया जाए। यह विशेष रूप से उपयोगी है:

  • बड़े फ़ाइलों या डेटा सेट्स के लिए।
  • रीयल-टाइम अपडेट्स (जैसे, चैट, प्रगति बार)।
  • लंबी चलने वाली गणनाओं के लिए जहां आप उपयोगकर्ता को सूचित रखना चाहते हैं।

यहाँ उच्च स्तर पर स्ट्रीमिंग के बारे में आपको क्या जानना चाहिए:

  • डेटा प्रगतिशील रूप से वितरित होता है, एक साथ नहीं।
  • क्लाइंट डेटा को आते ही संसाधित कर सकता है।
  • प्रत्याशित अतिरेक को कम करता है और उपयोगकर्ता अनुभव को सुधारता है।

स्ट्रीमिंग क्यों उपयोग करें?

स्ट्रीमिंग उपयोग करने के कारण निम्नलिखित हैं:

  • उपयोगकर्ताओं को तुरंत प्रतिक्रिया मिलती है, न कि सिर्फ अंत में
  • रीयल-टाइम एप्लिकेशन और प्रतिक्रियाशील UI सक्षम करता है
  • नेटवर्क और कंप्यूट संसाधनों का अधिक कुशल उपयोग

सरल उदाहरण: HTTP स्ट्रीमिंग सर्वर और क्लाइंट

यहां एक सरल उदाहरण है कि स्ट्रीमिंग कैसे लागू की जा सकती है:

पायथन

सर्वर (Python, FastAPI और StreamingResponse का उपयोग):

from fastapi import FastAPI
from fastapi.responses import StreamingResponse
import time

app = FastAPI()

async def event_stream():
    for i in range(1, 6):
        yield f"data: Message {i}\n\n"
        time.sleep(1)

@app.get("/stream")
def stream():
    return StreamingResponse(event_stream(), media_type="text/event-stream")

क्लाइंट (Python, requests का उपयोग):

import requests

with requests.get("http://localhost:8000/stream", stream=True) as r:
    for line in r.iter_lines():
        if line:
            print(line.decode())

यह उदाहरण दर्शाता है कि सर्वर कैसे उपलब्ध होते ही क्लाइंट को संदेशों की एक श्रृंखला भेजता है, बजाय इस के कि सभी संदेश तैयार होने का इंतजार किया जाए।

यह कैसे काम करता है:

  • सर्वर प्रत्येक संदेश को तैयार होते ही प्रेषित करता है।
  • क्लाइंट आते ही प्रत्येक टुकड़े को प्राप्त और प्रिंट करता है।

आवश्यकताएं:

  • सर्वर को स्ट्रीमिंग प्रतिक्रिया का उपयोग करना चाहिए (जैसे FastAPI में StreamingResponse)।
  • क्लाइंट को प्रतिक्रिया को स्ट्रीम के रूप में संसाधित करना चाहिए (requests में stream=True)।
  • कंटेंट-टाइप आमतौर पर text/event-stream या application/octet-stream होता है।

जावा

सर्वर (Java, Spring Boot और Server-Sent Events का उपयोग):

@RestController
public class CalculatorController {

    @GetMapping(value = "/calculate", produces = MediaType.TEXT_EVENT_STREAM_VALUE)
    public Flux<ServerSentEvent<String>> calculate(@RequestParam double a,
                                                   @RequestParam double b,
                                                   @RequestParam String op) {
        
        double result;
        switch (op) {
            case "add": result = a + b; break;
            case "sub": result = a - b; break;
            case "mul": result = a * b; break;
            case "div": result = b != 0 ? a / b : Double.NaN; break;
            default: result = Double.NaN;
        }

        return Flux.<ServerSentEvent<String>>just(
                    ServerSentEvent.<String>builder()
                        .event("info")
                        .data("Calculating: " + a + " " + op + " " + b)
                        .build(),
                    ServerSentEvent.<String>builder()
                        .event("result")
                        .data(String.valueOf(result))
                        .build()
                )
                .delayElements(Duration.ofSeconds(1));
    }
}

क्लाइंट (Java, Spring WebFlux WebClient का उपयोग):

@SpringBootApplication
public class CalculatorClientApplication implements CommandLineRunner {

    private final WebClient client = WebClient.builder()
            .baseUrl("http://localhost:8080")
            .build();

    @Override
    public void run(String... args) {
        client.get()
                .uri(uriBuilder -> uriBuilder
                        .path("/calculate")
                        .queryParam("a", 7)
                        .queryParam("b", 5)
                        .queryParam("op", "mul")
                        .build())
                .accept(MediaType.TEXT_EVENT_STREAM)
                .retrieve()
                .bodyToFlux(String.class)
                .doOnNext(System.out::println)
                .blockLast();
    }
}

जावा कार्यान्वयन नोट्स:

  • Spring Boot की रिएक्टिव स्टैक का उपयोग करता है Flux के लिए स्ट्रीमिंग के साथ
  • ServerSentEvent संरचित घटना स्ट्रीमिंग प्रदान करता है इवेंट प्रकारों के साथ
  • WebClient के साथ bodyToFlux() रिएक्टिव स्ट्रीमिंग खपत को सक्षम करता है
  • delayElements() घटनाओं के बीच प्रोसेसिंग समय को सिमुलेट करता है
  • घटनाओं के प्रकार हो सकते हैं (info, result) बेहतर क्लाइंट हैंडलिंग के लिए

तुलना: क्लासिक स्ट्रीमिंग बनाम MCP स्ट्रीमिंग

यहां दर्शाया गया है कि पारंपरिक स्ट्रीमिंग और MCP में स्ट्रीमिंग कैसे भिन्न होती है:

फीचरक्लासिक HTTP स्ट्रीमिंगMCP स्ट्रीमिंग (सूचनाएं)
मुख्य प्रतिक्रियाचंकिन्गएकल, अंत में
प्रगति अपडेट्सडेटा टुकड़ों के रूप में भेजा जाता हैसूचनाओं के रूप में भेजा जाता है
क्लाइंट आवश्यकताएंस्ट्रीम को संसाधित करना चाहिएसंदेश हैंडलर को लागू करना चाहिए
उपयोग मामलाबड़े फ़ाइलें, AI टोकन स्ट्रीम्सप्रगति, लॉग, रीयल-टाइम फीडबैक

देखे गए प्रमुख अंतर

इसके अलावा, कुछ मुख्य अंतर निम्नलिखित हैं:

  • संचार पैटर्न:

    • क्लासिक HTTP स्ट्रीमिंग: सरल चंकिन्ग ट्रांसफर एन्कोडिंग का उपयोग जाता है डेटा को टुकड़ों में भेजने के लिए
    • MCP स्ट्रीमिंग: JSON-RPC प्रोटोकॉल के साथ संरचित सूचना प्रणाली का उपयोग करता है

  • संदेश प्रारूप:

    • क्लासिक HTTP: सामान्य टेक्स्ट टुकड़े नई लाइनों के साथ
    • MCP: मेटाडेटा के साथ संरचित LoggingMessageNotification ऑब्जेक्ट्स

  • क्लाइंट कार्यान्वयन:

    • क्लासिक HTTP: सरल क्लाइंट जो स्ट्रीमिंग प्रतिक्रियाओं को संसाधित करता है
    • MCP: अधिक परिष्कृत क्लाइंट जिसमें विभिन्न प्रकार के संदेशों को संसाधित करने के लिए संदेश हैंडलर होता है

  • प्रगति अपडेट्स:

    • क्लासिक HTTP: प्रगति मुख्य प्रतिक्रिया स्ट्रीम का हिस्सा होती है
    • MCP: मुख्य प्रतिक्रिया अंत में आती है जबकि प्रगति अलग-अलग सूचना संदेशों के जरिए भेजी जाती है

सिफारिशें

हम कुछ बातें सुझाव देते हैं जब आप पारंपरिक स्ट्रीमिंग (जैसा की ऊपर /stream एंडपॉइंट में दिखाया गया) बनाम MCP के माध्यम से स्ट्रीमिंग को लागू करने के बीच चुन रहे हों।

  • सरल स्ट्रीमिंग जरूरतों के लिए: पारंपरिक HTTP स्ट्रीमिंग लागू करने में सरल है और बुनियादी स्ट्रीमिंग जरूरतों के लिए पर्याप्त है।

  • जटिल, इंटरैक्टिव एप्लिकेशन के लिए: MCP स्ट्रीमिंग अधिक संरचित दृष्टिकोण प्रदान करता है, जिसमें समृद्ध मेटाडेटा और सूचनाओं तथा अंतिम परिणाम के बीच अलगाव होता है।

  • AI एप्लिकेशन के लिए: MCP का सूचना प्रणाली विशेष रूप से उन लंबी चलने वाली AI कार्यों के लिए उपयोगी है जहां आप उपयोगकर्ताओं को प्रगति से सूचित रखना चाहते हैं।

MCP में स्ट्रीमिंग

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

MCP फ्रेमवर्क में स्ट्रीमिंग कैसे काम करता है, इसे समझना आवश्यक है ताकि आप प्रतिक्रियाशील एप्लिकेशन बना सकें जो लंबी चलने वाली क्रियाओं के दौरान उपयोगकर्ताओं को रीयल-टाइम फीडबैक प्रदान करते हैं।

MCP में, स्ट्रीमिंग का मतलब मुख्य प्रतिक्रिया को टुकड़ों में भेजना नहीं है, बल्कि अनुरोध संसाधित होने के दौरान क्लाइंट को सूचनाएं भेजना है। ये सूचनाएं प्रगति अपडेट, लॉग, या अन्य घटनाएं हो सकती हैं।

यह कैसे काम करता है

मुख्य परिणाम अभी भी एकल प्रतिक्रिया के रूप में भेजा जाता है। हालांकि, प्रक्रिया के दौरान अलग संदेशों के रूप में सूचनाएं भेजी जा सकती हैं और इस प्रकार क्लाइंट को रीयल टाइम में अपडेट किया जाता है। क्लाइंट को इन सूचनाओं को संभालने और प्रदर्शित करने में सक्षम होना चाहिए।

सूचना (Notification) क्या है?

हमने कहा "सूचना", MCP के संदर्भ में इसका क्या अर्थ है?

एक सूचना वह संदेश है जो सर्वर से क्लाइंट को भेजा जाता है ताकि लंबी चलने वाली प्रक्रिया के दौरान प्रगति, स्थिति, या अन्य घटनाओं के बारे में सूचित किया जा सके। सूचनाएं पारदर्शिता और उपयोगकर्ता अनुभव को बेहतर बनाती हैं।

उदाहरण के लिए, क्लाइंट को सूचना भेजनी चाहिए जब प्रारंभिक हैंडशेक सर्वर के साथ हो चुका हो।

एक सूचना JSON संदेश के रूप में इस प्रकार दिखती है:

{
  jsonrpc: "2.0";
  method: string;
  params?: {
    [key: string]: unknown;
  };
}

सूचनाएं MCP के उस टॉपिक से संबंधित हैं जिसे "Logging" कहा जाता है।

लॉगिंग को काम करने के लिए, सर्वर को इसे फीचर/क्षमता के रूप में सक्षम करना होता है, जैसा की इस प्रकार:

{
  "capabilities": {
    "logging": {}
  }
}

Note

उपयोग किए गए SDK के आधार पर, लॉगिंग डिफ़ॉल्ट रूप से सक्षम हो सकता है, या आपको यह स्पष्ट रूप से अपने सर्वर कॉन्फ़िगरेशन में सक्षम करना पड़ सकता है।

विभिन्न प्रकार की सूचनाएं होती हैं:

स्तरविवरणउदाहरण उपयोग मामला
debugविस्तृत डिबगिंग जानकारीफंक्शन प्रवेश/निकास बिंदु
infoसामान्य सूचना संदेशऑपरेशन प्रगति अपडेट्स
noticeसामान्य लेकिन महत्वपूर्ण घटनाएंकॉन्फ़िगरेशन परिवर्तन
warningचेतावनी की स्थितियांडिप्रिकेटेड फीचर उपयोग
errorत्रुटि स्थितियांऑपरेशन विफलताएं
criticalगंभीर स्थितियांसिस्टम घटक विफलताएं
alertतुरंत कार्रवाई की आवश्यकताडेटा भ्रष्टाचार का पता लगा
emergencyसिस्टम अनुपयोगी हैपूर्ण सिस्टम विफलता

MCP में सूचनाओं को लागू करना

MCP में सूचनाओं को लागू करने के लिए, आपको दोनों सर्वर और क्लाइंट पक्षों को रीयल-टाइम अपडेट्स को संभालने के लिए सेट अप करना होगा। इससे आपका एप्लिकेशन लंबी चलने वाली प्रक्रियाओं के दौरान उपयोगकर्ताओं को त्वरित प्रतिक्रिया प्रदान कर सकता है।

सर्वर-साइड: सूचनाएं भेजना

आइए सर्वर पक्ष से शुरू करें। MCP में, आप ऐसे टूल परिभाषित करते हैं जो अनुरोध संसाधित करते समय सूचनाएं भेज सकते हैं। सर्वर क्लाइंट को संदेश भेजने के लिए संदर्भ ऑब्जेक्ट (आमतौर पर ctx) का उपयोग करता है।

पायथन

@mcp.tool(description="A tool that sends progress notifications")
async def process_files(message: str, ctx: Context) -> TextContent:
    await ctx.info("Processing file 1/3...")
    await ctx.info("Processing file 2/3...")
    await ctx.info("Processing file 3/3...")
    return TextContent(type="text", text=f"Done: {message}")

पिछले उदाहरण में, process_files टूल प्रत्येक फ़ाइल संसाधित करते समय क्लाइंट को तीन सूचनाएं भेजता है। ctx.info() मेथड का उपयोग सूचना संदेश भेजने के लिए किया गया है।

अतिरिक्त रूप से, सूचनाएं सक्षम करने के लिए सुनिश्चित करें कि आपका सर्वर स्ट्रीमिंग ट्रांसपोर्ट (जैसे streamable-http) का उपयोग करता है और आपका क्लाइंट सूचनाओं को संसाधित करने के लिए संदेश हैंडलर को लागू करता है। यहाँ बताया गया है कि आप सर्वर को streamable-http ट्रांसपोर्ट का उपयोग करने के लिए कैसे सेट अप कर सकते हैं:

mcp.run(transport="streamable-http")

.NET

[Tool("A tool that sends progress notifications")]
public async Task<TextContent> ProcessFiles(string message, ToolContext ctx)
{
    await ctx.Info("Processing file 1/3...");
    await ctx.Info("Processing file 2/3...");
    await ctx.Info("Processing file 3/3...");
    return new TextContent
    {
        Type = "text",
        Text = $"Done: {message}"
    };
}

इस .NET उदाहरण में, ProcessFiles टूल पर Tool विशेषता लागू है और यह प्रत्येक फ़ाइल संसाधित करते समय क्लाइंट को तीन सूचनाएं भेजता है। सूचना संदेश भेजने के लिए ctx.Info() मेथड का उपयोग किया गया है।

अपने .NET MCP सर्वर में सूचनाएं सक्षम करने के लिए सुनिश्चित करें कि आप स्ट्रीमिंग ट्रांसपोर्ट का उपयोग कर रहे हैं:

var builder = McpBuilder.Create();
await builder
    .UseStreamableHttp() // Enable streamable HTTP transport
    .Build()
    .RunAsync();

क्लाइंट-साइड: सूचनाएं प्राप्त करना

क्लाइंट को एक संदेश हैंडलर को लागू करना होता है जो सूचनाओं को प्राप्त करने और प्रदर्शित करने में सक्षम हो।

पायथन

async def message_handler(message):
    if isinstance(message, types.ServerNotification):
        print("NOTIFICATION:", message)
    else:
        print("SERVER MESSAGE:", message)

async with ClientSession(
   read_stream, 
   write_stream,
   logging_callback=logging_collector,
   message_handler=message_handler,
) as session:

पिछले कोड में, message_handler फ़ंक्शन जांचता है कि क्या आने वाला संदेश सूचना है। यदि है, तो यह सूचना प्रिंट करता है; अन्यथा, इसे एक सामान्य सर्वर संदेश के रूप में संसाधित करता है। ध्यान दें कि ClientSession को message_handler के साथ इनिशियलाइज़ किया गया है ताकि आने वाली सूचनाओं को संभाला जा सके।

.NET

// Define a message handler
void MessageHandler(IJsonRpcMessage message)
{
    if (message is ServerNotification notification)
    {
        Console.WriteLine($"NOTIFICATION: {notification}");
    }
    else
    {
        Console.WriteLine($"SERVER MESSAGE: {message}");
    }
}

// Create and use a client session with the message handler
var clientOptions = new ClientSessionOptions
{
    MessageHandler = MessageHandler,
    LoggingCallback = (level, message) => Console.WriteLine($"[{level}] {message}")
};

using var client = new ClientSession(readStream, writeStream, clientOptions);
await client.InitializeAsync();

// Now the client will process notifications through the MessageHandler

इस .NET उदाहरण में, MessageHandler फ़ंक्शन जांचता है कि क्या आने वाला संदेश सूचना है। यदि हाँ, तो यह सूचना प्रिंट करता है; अन्यथा यह इसे सामान्य सर्वर संदेश के रूप में संसाधित करता है। ClientSession को ClientSessionOptions के माध्यम से संदेश हैंडलर के साथ इनिशियलाइज़ किया गया है।

सूचनाएं सक्षम करने के लिए सुनिश्चित करें कि आपका सर्वर स्ट्रीमिंग ट्रांसपोर्ट (जैसे streamable-http) का उपयोग करता हो और आपका क्लाइंट सूचनाओं को संसाधित करने के लिए संदेश हैंडलर को लागू करता हो।

प्रगति सूचनाएं और परिदृश्य

यह अनुभाग MCP में प्रगति सूचनाओं की अवधारणा, उनका महत्व, और Streamable HTTP का उपयोग करके उन्हें कैसे लागू किया जाए, इसे समझाता है। आप अपनी समझ को मजबूत करने के लिए एक व्यावहारिक असाइनमेंट भी पाएंगे।

प्रगति सूचनाएं वे रीयल-टाइम संदेश हैं जो लंबी चलने वाली प्रक्रियाओं के दौरान सर्वर से क्लाइंट को भेजे जाते हैं। पूरी प्रक्रिया के खत्म होने का इंतजार करने के बजाय, सर्वर क्लाइंट को वर्तमान स्थिति के बारे में अपडेट रखता है। इससे पारदर्शिता, उपयोगकर्ता अनुभव बेहतर होता है और डिबगिंग आसान हो जाती है।

उदाहरण:


"Processing document 1/10"
"Processing document 2/10"
...
"Processing complete!"

प्रगति सूचनाएं क्यों उपयोग करें?

प्रगति सूचनाएं कई कारणों से आवश्यक हैं:

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

प्रगति सूचनाएं कैसे लागू करें

यहां बताया गया है कि MCP में प्रगति सूचनाएं कैसे लागू की जा सकती हैं:

  • सर्वर पर: ctx.info() या ctx.log() का उपयोग करके जैसे-जैसे प्रत्येक आइटम संसाधित होता है सूचनाएं भेजें। यह मुख्य परिणाम तैयार होने से पहले क्लाइंट को संदेश भेजता है।
  • क्लाइंट पर: एक संदेश हैंडलर लागू करें जो सूचनाओं को सुनता है और जैसे ही वे पहुंचती हैं उन्हें प्रदर्शित करता है। यह हैंडलर सूचनाओं और अंतिम परिणाम के बीच अंतर करता है।

सर्वर उदाहरण:

पायथन

@mcp.tool(description="A tool that sends progress notifications")
async def process_files(message: str, ctx: Context) -> TextContent:
    for i in range(1, 11):
        await ctx.info(f"Processing document {i}/10")
    await ctx.info("Processing complete!")
    return TextContent(type="text", text=f"Done: {message}")

क्लाइंट उदाहरण:

पायथन

async def message_handler(message):
    if isinstance(message, types.ServerNotification):
        print("NOTIFICATION:", message)
    else:
        print("SERVER MESSAGE:", message)

सुरक्षा विचार

जब HTTP आधारित ट्रांसपोर्ट के साथ MCP सर्वरों को लागू किया जाता है, तो सुरक्षा एक सर्वोच्च चिंता बन जाती है, जिससे कई हमले के वेक्टर और सुरक्षा तंत्रों पर सावधानीपूर्वक ध्यान देना आवश्यक होता है।

अवलोकन

HTTP पर MCP सर्वरों को एक्सपोज़ करते समय सुरक्षा महत्वपूर्ण होती है। Streamable HTTP नए हमले के सतह (attack surfaces) प्रस्तुत करता है और सावधानीपूर्वक कॉन्फ़िगरेशन की मांग करता है।

प्रमुख बिंदु

  • Origin हेडर मान्यता: DNS रिबाइंडिंग हमलों को रोकने के लिए हमेशा Origin हेडर को मान्य करें।
  • लोकलहोस्ट बाइंडिंग: स्थानीय विकास के लिए, सर्वरों को localhost पर बाइंड करें ताकि वे सार्वजनिक इंटरनेट के लिए एक्सपोज़ न हों।
  • प्रमाणीकरण: उत्पादन परिनियोजन के लिए प्रमाणीकरण (जैसे API कुंजी, OAuth) लागू करें।
  • CORS: एक्सेस को सीमित करने के लिए क्रॉस-ओरिजिन रिसोर्स शेयरिंग (CORS) नीतियों को कॉन्फ़िगर करें।
  • HTTPS: उत्पादन में ट्रैफ़िक को एन्क्रिप्ट करने के लिए HTTPS का उपयोग करें।

सर्वोत्तम प्रथाएं

  • बिना मान्यता के आने वाले अनुरोधों पर कभी भरोसा न करें।
  • सभी एक्सेस और त्रुटियों को लॉग और मॉनिटर करें।
  • सुरक्षा कमजोरियों को पैच करने के लिए नियमित रूप से डिपेंडेंसी अपडेट करें।

चुनौतियां

  • सुरक्षा और विकास में आसानी के बीच संतुलन बनाना
  • विभिन्न क्लाइंट वातावरणों के साथ संगतता सुनिश्चित करना

SSE से Streamable HTTP में अपग्रेड करना

जो एप्लिकेशन वर्तमान में Server-Sent Events (SSE) का उपयोग कर रहे हैं, उनके लिए Streamable HTTP में माइग्रेशन आपके MCP इम्प्लीमेंटेशन के लिए बेहतर क्षमताएं और दीर्घकालिक स्थिरता प्रदान करता है।

अपग्रेड क्यों करें?

SSE से Streamable HTTP में अपग्रेड करने के दो मुख्य कारण हैं:

  • Streamable HTTP, SSE की तुलना में बेहतर स्केलेबिलिटी, संगतता, और समृद्ध नोटिफिकेशन सपोर्ट प्रदान करता है।
  • यह नए MCP एप्लिकेशनों के लिए अनुशंसित ट्रांसपोर्ट है।

माइग्रेशन चरण

यहाँ बताया गया है कि आप अपने MCP एप्लिकेशनों में SSE से Streamable HTTP पर कैसे माइग्रेट कर सकते हैं:

  • सरवर कोड अपडेट करें ताकि mcp.run() में transport="streamable-http" का उपयोग हो।
  • क्लाइंट कोड अपडेट करें ताकि SSE क्लाइंट की जगह streamablehttp_client का उपयोग हो।
  • क्लाइंट में एक संदेश हैंडलर लागू करें जो नोटिफिकेशन को प्रोसेस करे।
  • मौजूदा उपकरणों और वर्कफ़्लो के साथ संगतता के लिए परीक्षण करें।

संगतता बनाए रखना

माइग्रेशन प्रक्रिया के दौरान मौजूदा SSE क्लाइंट्स के साथ संगतता बनाए रखना अनुशंसित है। यहाँ कुछ रणनीतियाँ हैं:

  • आप दोनों SSE और Streamable HTTP को अलग-अलग एंडपॉइंट्स पर चलाकर समर्थन कर सकते हैं।
  • धीरे-धीरे क्लाइंट्स को नए ट्रांसपोर्ट में माइग्रेट करें।

चुनौतियाँ

माइग्रेशन के दौरान निम्न चुनौतियों को संबोधित करना आवश्यक है:

  • सभी क्लाइंट्स के अपडेट होना सुनिश्चित करना
  • नोटिफिकेशन डिलीवरी में अंतर को संभालना

सुरक्षा विचार

HTTP-आधारित ट्रांसपोर्ट जैसे Streamable HTTP का उपयोग करते समय सुरक्षा सर्वोच्च प्राथमिकता होनी चाहिए, खासकर MCP सर्वर को लागू करते समय।

HTTP-आधारित ट्रांसपोर्ट के साथ MCP सर्वरों के कार्यान्वयन में सुरक्षा अनेक हमलों के वेक्टर और सुरक्षा उपायों के सावधानीपूर्वक संयोजन की मांग करती है।

अवलोकन

MCP सर्वरों को HTTP के माध्यम से एक्सपोज़ करते समय सुरक्षा महत्वपूर्ण होती है। Streamable HTTP नए हमले के क्षेत्रों को बढ़ाता है और सावधानीपूर्वक कॉन्फ़िगरेशन की आवश्यकता होती है।

कुछ मुख्य सुरक्षा विचार निम्नलिखित हैं:

  • Origin हेडर मान्यता: DNS रिबाइंडिंग हमलों को रोकने के लिए प्रत्येक Origin हेडर का सत्यापन करें।
  • लोकलहोस्ट बाइंडिंग: स्थानीय विकास के लिए सर्वरों को localhost पर बाइंड करें ताकि उन्हें सार्वजनिक इंटरनेट से उजागर न किया जाए।
  • प्रमाणीकरण: उत्पादन तैनाती में प्रमाणीकरण लागू करें (जैसे API कीज़, OAuth)।
  • CORS: एक्सेस प्रतिबंधित करने के लिए क्रॉस-ओरिजिन रिसोर्स शेयरिंग (CORS) नीतियाँ कॉन्फ़िगर करें।
  • HTTPS: उत्पादन में ट्रैफ़िक एन्क्रिप्ट करने के लिए HTTPS का उपयोग करें।

सर्वोत्तम प्रथाएँ

सुरक्षा लागू करते समय निम्न सर्वोत्तम प्रथाओं का पालन करें:

  • बिना सत्यापन के आने वाले अनुरोधों पर भरोसा न करें।
  • सभी एक्सेस और त्रुटियों को लॉग और मॉनिटर करें।
  • सुरक्षा कमजोरी पैच करने के लिए निर्भरताओं को नियमित रूप से अपडेट करें।

चुनौतियाँ

MCP स्ट्रीमिंग सर्वर में सुरक्षा लागू करते समय आपको निम्न चुनौतियों का सामना करना पड़ेगा:

  • सुरक्षा और विकास में आसानी के बीच संतुलन बनाना
  • विभिन्न क्लाइंट वातावरणों के साथ संगतता सुनिश्चित करना

असाइनमेंट: अपनी खुद की स्ट्रीमिंग MCP एप्लिकेशन बनाएं

परिदृश्य:
एक MCP सर्वर और क्लाइंट बनाएं जहां सर्वर आइटम (जैसे फाइलें या दस्तावेज़) की एक सूची प्रोसेस करता है और प्रत्येक प्रोसेस किए गए आइटम के लिए नोटिफिकेशन भेजता है। क्लाइंट को प्रत्येक नोटिफिकेशन आते ही दिखाना चाहिए।

चरण:

  1. एक सर्वर टूल लागू करें जो सूची प्रोसेस करे और प्रत्येक आइटम के लिए नोटिफिकेशन भेजे।
  2. एक क्लाइंट लागू करें जिसमें एक संदेश हैंडलर हो जो रियल-टाइम में नोटिफिकेशन दिखाए।
  3. अपनी कार्यान्वयन का परीक्षण करें—दोनों सर्वर और क्लाइंट को चलाएं और नोटिफिकेशन देखें।

Solution

आगे पढ़ें और आगे क्या?

अपने MCP स्ट्रीमिंग के सफर को जारी रखने और अपने ज्ञान को बढ़ाने के लिए यह अनुभाग अतिरिक्त संसाधन और अधिक उन्नत एप्लिकेशन बनाने के लिए सुझाव देता है।

आगे पढ़ें

आगे क्या करें?

  • रियल-टाइम एनालिटिक्स, चैट या सहयोगी संपादन के लिए स्ट्रीमिंग का उपयोग करने वाले अधिक उन्नत MCP टूल्स बनाना आज़माएं।
  • लाइव UI अपडेट्स के लिए फ्रंटेंड फ्रेमवर्क (React, Vue, आदि) के साथ MCP स्ट्रीमिंग को एकीकृत करना एक्सप्लोर करें।
  • अगला: VSCode के लिए AI Toolkit का उपयोग

अस्वीकरण: इस दस्तावेज़ का अनुवाद AI अनुवाद सेवा Co-op Translator का उपयोग करके किया गया है। जबकि हम सटीकता के लिए प्रयास करते हैं, कृपया ध्यान दें कि स्वचालित अनुवादों में त्रुटियाँ या अशुद्धियाँ हो सकती हैं। मूल दस्तावेज़ अपनी मूल भाषा में ही प्रामाणिक स्रोत माना जाना चाहिए। महत्वपूर्ण जानकारी के लिए, पेशेवर मानव अनुवाद की सिफारिश की जाती है। इस अनुवाद के उपयोग से उत्पन्न किसी भी गलतफहमी या गलत व्याख्या के लिए हम उत्तरदायी नहीं हैं।